Ruby on Rails - Guide rapide
Qu'est-ce que Ruby?
Avant de rouler sur Rails, récapitulons quelques points de Ruby, qui est la base de Rails.
Ruby est la combinaison réussie de -
- L'élégance conceptuelle de Smalltalk,
- La facilité d'utilisation et d'apprentissage de Python, et
- Le pragmatisme de Perl.
Ruby est -
- Un langage de programmation de haut niveau.
- Interprété comme Perl, Python, Tcl / TK.
- Orienté objet comme Smalltalk, Eiffel, Ada, Java.
Pourquoi Ruby?
Le rubis est originaire du Japon et gagne maintenant en popularité aux États-Unis et en Europe. Les facteurs suivants contribuent à sa popularité -
- Facile à apprendre
- Open source (licence très libérale)
- Bibliothèques riches
- Très facile à prolonger
- Vraiment orienté objet
- Moins de codage avec moins de bogues
- Communauté utile
Bien que nous ayons de nombreuses raisons d'utiliser Ruby, il existe également quelques inconvénients que vous devrez peut-être prendre en compte avant d'implémenter Ruby -
Performance Issues - Bien qu'il rivalise avec Perl et Python, c'est toujours un langage interprété et nous ne pouvons pas le comparer avec des langages de programmation de haut niveau comme C ou C ++.
Threading model- Ruby n'utilise pas de threads natifs. Les threads Ruby sont simulés dans la machine virtuelle plutôt que de s'exécuter en tant que threads natifs du système d'exploitation.
Exemple de code Ruby
Voici un exemple de code Ruby pour imprimer "Hello Ruby"
# The Hello Class
class Hello
def initialize( name )
@name = name.capitalize
end
def salute
puts "Hello #{@name}!"
end
end
# Create a new object
h = Hello.new("Ruby")
# Output "Hello Ruby!"
h.saluteOutput - Cela produira le résultat suivant -
Hello Ruby!Rubis intégré
Ruby fournit un programme appelé ERB (Embedded Ruby), écrit par Seki Masatoshi . ERB vous permet de mettre des codes Ruby dans un fichier HTML. ERB lit, mot pour mot, puis à un certain moment, lorsqu'il rencontre un code Ruby intégré dans le document, il commence à exécuter le code Ruby.
Vous devez savoir seulement deux choses pour préparer un document ERB -
Si vous voulez exécuter du code Ruby, placez-le entre <% et %>.
Si vous souhaitez que le résultat de l'exécution du code soit imprimé, dans le cadre de la sortie, placez le code entre <%= et %>.
Voici un exemple. Enregistrez le code dans le fichier erbdemo.rb. Notez qu'un fichier Ruby aura une extension.rb -
<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>
<html>
<head>
<title><%= page_title %></title>
</head>
<body>
<p><%= salutation %></p>
<p>This is an example of how ERB fills out a template.</p>
</body>
</html>Maintenant, exécutez le programme à l'aide de l'utilitaire de ligne de commande erb.
tp> erb erbdemo.rbCela produira le résultat suivant -
<html>
<head>
<title>Demonstration of ERb</title>
</head>
<body>
<p>Dear programmer,</p>
<p>This is an example of how ERb fills out a template.</p>
</body>
</html>Qu'est-ce que les rails?
Un cadre d'application Web extrêmement productif.
Écrit en rubis par David Heinemeier Hansson.
Vous pouvez développer une application Web au moins dix fois plus rapidement avec Rails qu'avec un framework Java classique.
Un framework Ruby open source pour le développement d'applications Web basées sur des bases de données.
Configurez votre code avec le schéma de base de données.
Aucune phase de compilation requise.
Framework Full Stack
Inclut tout le nécessaire pour créer une application Web basée sur une base de données, en utilisant le modèle Model-View-Controller.
Être un framework full-stack signifie que toutes les couches sont conçues pour fonctionner de manière transparente avec moins de code.
Nécessite moins de lignes de code que les autres frameworks.
Convention sur la configuration
Rails évite les fichiers de configuration au profit des conventions, de la réflexion et des extensions d'exécution dynamiques.
Votre code d'application et votre base de données en cours d'exécution contiennent déjà tout ce que Rails a besoin de savoir!
Points forts des rails
Rails regorge de fonctionnalités qui vous rendent plus productif, la plupart des fonctionnalités suivantes se renforçant les unes sur les autres.
Métaprogrammation
Là où d'autres frameworks utilisent une génération de code étendue à partir de zéro, Rail Framework utilise des techniques de métaprogrammation pour écrire des programmes. Ruby est l'un des meilleurs langages pour la métaprogrammation, et Rails utilise bien cette fonctionnalité. Rails utilise également la génération de code mais s'appuie beaucoup plus sur la métaprogrammation pour les tâches lourdes.
Enregistrement actif
Rails introduit le framework Active Record, qui enregistre les objets dans la base de données. La version Rails de l'enregistrement actif découvre les colonnes dans un schéma de base de données et les attache automatiquement à vos objets de domaine à l'aide de la métaprogrammation.
Convention sur la configuration
La plupart des frameworks de développement Web pour .NET ou Java vous obligent à écrire des pages de code de configuration. Si vous suivez les conventions de dénomination suggérées, Rails n'a pas besoin de beaucoup de configuration.
Échafaudage
Vous créez souvent du code temporaire au tout début du développement pour aider à démarrer rapidement une application et voir comment les principaux composants fonctionnent ensemble. Les rails créent automatiquement une grande partie de l'échafaudage dont vous aurez besoin.
Test intégré
Rails crée des tests automatisés simples que vous pouvez ensuite étendre. Rails fournit également un code de support appelé harnais et fixtures qui facilite l'écriture et l'exécution des cas de test. Ruby peut ensuite exécuter tous vos tests automatisés avec l'utilitaire rake.
Trois environnements
Rails vous propose trois environnements par défaut: développement, test et production. Chacun se comporte légèrement différemment, ce qui facilite l'ensemble de votre cycle de développement logiciel. Par exemple, Rails crée une nouvelle copie de la base de données de test pour chaque exécution de test.
Pour développer une application Web à l'aide de Ruby on Rails Framework, vous devez installer le logiciel suivant -
- Ruby
- Le cadre Rails
- Un serveur Web
- Un système de base de données
Nous supposons que vous avez déjà installé un serveur Web et un système de base de données sur votre ordinateur. Vous pouvez utiliser le serveur Web WEBrick, fourni avec Ruby. La plupart des sites Web utilisent cependant des serveurs Web Apache ou lightTPD en production.
Rails fonctionne avec de nombreux systèmes de base de données, notamment MySQL, PostgreSQL, SQLite, Oracle, DB2 et SQL Server. Veuillez consulter un manuel de configuration du système de base de données correspondant pour configurer votre base de données.
Regardons les instructions d'installation de Rails sur Windows et Linux.
Installation des rails sous Windows
Suivez les étapes ci-dessous pour installer Ruby on Rails.
Étape 1: Vérifiez la version de Ruby
Tout d'abord, vérifiez si vous avez déjà installé Ruby. Ouvrez l'invite de commande et tapezruby -v. Si Ruby répond, et s'il affiche un numéro de version supérieur ou égal à 2.2.2, tapezgem --version. Si vous n'obtenez pas d'erreur, ignorezInstall Rubyétape. Sinon, nous installerons un nouveau Ruby.
Étape 2: Installez Ruby
Si Ruby n'est pas installé, téléchargez un package d'installation à partir de rubyinstaller.org. Suivre ladownloadlink et exécutez le programme d'installation résultant. Ceci est un fichier exerubyinstaller-2.2.2.x.exeet sera installé en un seul clic. C'est un très petit paquet, et vous obtiendrez également RubyGems avec ce paquet. S'il vous plaît, vérifiez leRelease Notes pour plus de détails.
Étape 3: Installez les rails
Install Rails - Avec Rubygems chargé, vous pouvez installer tous les Rails et ses dépendances en utilisant la commande suivante via la ligne de commande -
C:\> gem install rails
Note- La commande ci-dessus peut prendre un certain temps pour installer toutes les dépendances. Assurez-vous que vous êtes connecté à Internet lors de l'installation des dépendances de gemmes.
Étape 4: Vérifiez la version des rails
Utilisez la commande suivante pour vérifier la version des rails.
C:\> rails -vOutput
Rails 4.2.4Toutes nos félicitations! Vous êtes maintenant sur Rails sur Windows.
Installation de Rails sur Linux
Nous installons Ruby On Rails sur Linux en utilisant rbenv. Il s'agit d'un outil de gestion de version Ruby léger. lerbenv fournit une procédure d'installation simple pour gérer différentes versions de Ruby et un environnement solide pour le développement d'applications Ruby on Rails.
Suivez les étapes ci-dessous pour installer Ruby on Rails à l'aide de l'outil rbenv.
Étape 1: installer les dépendances prérequises
Tout d'abord, nous devons installer git - coreet quelques dépendances ruby qui aident à installer Ruby on Rails. Utilisez la commande suivante pour installer les dépendances Rails à l'aide deyum.
tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-develÉtape 2: Installez rbenv
Nous allons maintenant installer rbenv et définir les variables d'environnement appropriées. Utilisez l'ensemble de commandes suivant pour obtenir rbenv pour le référentiel git.
tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
tp> exec $SHELL
tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELLÉtape 3: Installez Ruby
Avant d'installer Ruby, déterminez la version de Ruby que vous souhaitez installer. Nous installerons Ruby 2.2.3. Utilisez la commande suivante pour installer Ruby.
tp> rbenv install -v 2.2.3Utilisez la commande suivante pour configurer la version actuelle de Ruby par défaut.
tp> rbenv global 2.2.3Utilisez la commande suivante pour vérifier la version de Ruby.
tp> ruby -vOutput
ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]Ruby fournit un mot-clé gempour installer les dépendances prises en charge; nous les appelonsgems. Si vous ne souhaitez pas installer la documentation de Ruby-gems, utilisez la commande suivante.
tp> echo "gem: --no-document" > ~/.gemrcPar la suite, il est préférable d'installer le gem Bundler, car il permet de gérer les dépendances de vos applications. Utilisez la commande suivante pour installer le bundler gem.
tp> gem install bundlerÉtape 4: Installez les rails
Utilisez la commande suivante pour installer Rails version 4.2.4.
tp> install rails -v 4.2.4Utilisez la commande suivante pour rendre l'exécutable Rails disponible.
tp> rbenv rehashUtilisez la commande suivante pour vérifier la version des rails.
tp> rails -vOutput
tp> Rails 4.2.4Le framework Ruby on Rails nécessite JavaScript Runtime Environment (Node.js) pour gérer les fonctionnalités de Rails. Ensuite, nous verrons comment nous pouvons utiliser Node.js pour gérer le pipeline d'actifs, une fonctionnalité Rails.
Étape 5: Installez JavaScript Runtime
Installons Node.js à partir du référentiel Yum. Nous allons prendre Node.js du référentiel EPEL yum. Utilisez la commande suivante pour ajouter le package EPEL au référentiel yum.
tp> sudo yum -y install epel-releaseUtilisez la commande suivante pour installer le package Node.js.
tp> sudo yum install nodejsToutes nos félicitations! Vous êtes maintenant sur Rails sur Linux.
Étape 6: installer la base de données
Par défaut, Rails utilise sqlite3, mais vous souhaiterez peut-être installer MySQL, PostgreSQL ou un autre SGBDR. Ceci est facultatif; si la base de données est installée, vous pouvez ignorer cette étape et il n'est pas obligatoire qu'une base de données soit installée pour démarrer le serveur rails. Pour ce tutoriel, nous utilisons la base de données PostgreSQL. Utilisez donc les commandes suivantes pour installer PostgreSQL.
tp> sudo yum install postgresql-server postgresql-contribAcceptez l'invite en répondant par un y. Utilisez la commande suivante pour créer un cluster de base de données PostgreSQl.
tp> sudo postgresql-setup initdbUtilisez la commande suivante pour démarrer et activer PostgreSQL.
tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresqlMaintenir les rails à jour
En supposant que vous ayez installé Rails à l'aide de RubyGems, le maintenir à jour est relativement facile. Nous pouvons utiliser la même commande dans les plates-formes Windows et Linux. Utilisez la commande suivante -
tp> gem update railsOutput
La capture d'écran suivante montre une invite de commande Windows. Le terminal Linux fournit également la même sortie.
Cela mettra automatiquement à jour votre installation Rails. La prochaine fois que vous redémarrerez votre application, elle récupérera cette dernière version de Rails. Lorsque vous utilisez cette commande, assurez-vous que vous êtes connecté à Internet.
Vérification de l'installation
Vous pouvez vérifier si tout est configuré selon vos besoins ou non. Utilisez la commande suivante pour créer un projet de démonstration.
tp> rails new demoOutput
Il générera un projet ferroviaire de démonstration; nous en discuterons plus tard. Actuellement, nous devons vérifier si l'environnement est configuré ou non. Ensuite, utilisez la commande suivante pour exécuter le serveur Web WEBrick sur votre machine.
tp> cd demo
tp> rails serverIl générera un code automatique pour démarrer le serveur
Ouvrez maintenant votre navigateur et tapez ce qui suit -
http://localhost:3000Il doit afficher un message du type "Bienvenue à bord" ou "Félicitations".
Un framework est un programme, un ensemble de programmes et / ou une bibliothèque de codes qui écrit la plupart de votre application pour vous. Lorsque vous utilisez un framework, votre travail consiste à écrire les parties de l'application qui lui permettent de faire les choses spécifiques que vous souhaitez.
Lorsque vous décidez d'écrire une application Rails, en laissant de côté la configuration et les autres tâches ménagères, vous devez effectuer trois tâches principales:
Describe and model your application's domain- Le domaine est l'univers de votre application. Le domaine peut être un magasin de musique, une université, un service de rencontres, un carnet d'adresses ou un inventaire matériel. Donc, ici, vous devez comprendre ce qu'il contient, quelles entités existent dans cet univers et comment les éléments qu'il contient sont liés les uns aux autres. Cela équivaut à modéliser une structure de base de données pour conserver les entités et leurs relations.
Specify what can happen in this domain- Le modèle de domaine est statique; il faut le rendre dynamique. Des adresses peuvent être ajoutées à un carnet d'adresses. Les partitions musicales peuvent être achetées dans les magasins de musique. Les utilisateurs peuvent se connecter à un service de rencontres. Les étudiants peuvent s'inscrire à des cours dans une université. Vous devez identifier tous les scénarios ou actions possibles auxquels les éléments de votre domaine peuvent participer.
Choose and design the publicly available views of the domain- À ce stade, vous pouvez commencer à penser en termes de navigateur Web. Une fois que vous avez décidé que votre domaine a des étudiants et qu'ils peuvent s'inscrire aux cours, vous pouvez imaginer une page d'accueil, une page d'inscription et une page de confirmation, etc. Chacune de ces pages, ou vues, montre à l'utilisateur comment les choses se tenir à un certain moment.
Sur la base des trois tâches ci-dessus, Ruby on Rails traite un framework Model / View / Controller (MVC).
Cadre MVC Ruby on Rails
le Model View CLe principe d'un contrôleur divise le travail d'une application en trois sous-systèmes distincts mais étroitement coopératifs.
Modèle (ActiveRecord)
Il maintient la relation entre les objets et la base de données et gère la validation, l'association, les transactions, etc.
Ce sous-système est implémenté dans la bibliothèque ActiveRecord, qui fournit une interface et une liaison entre les tables d'une base de données relationnelle et le code du programme Ruby qui manipule les enregistrements de la base de données. Les noms de méthode Ruby sont automatiquement générés à partir des noms de champ des tables de base de données.
Vue (ActionView)
Il s'agit d'une présentation de données dans un format particulier, déclenchée par la décision d'un responsable du traitement de présenter les données. Ce sont des systèmes de modèles basés sur des scripts comme JSP, ASP, PHP et très faciles à intégrer avec la technologie AJAX.
Ce sous-système est implémenté dans la bibliothèque ActionView, qui est un système basé sur Embedded Ruby (ERb) pour définir des modèles de présentation pour la présentation des données. Chaque connexion Web à une application Rails entraîne l'affichage d'une vue.
Contrôleur (ActionController)
La fonction au sein de l'application qui dirige le trafic, d'une part, interrogeant les modèles pour des données spécifiques et, d'autre part, organisant ces données (recherche, tri, messagerie) sous une forme qui correspond aux besoins d'une vue donnée.
Ce sous-système est implémenté dans ActionController, qui est un courtier de données situé entre ActiveRecord (l'interface de base de données) et ActionView (le moteur de présentation).
Représentation illustrée du cadre MVC
Ci-dessous, une représentation illustrée de Ruby on Rails Framework -
Représentation d'annuaire de MVC Framework
En supposant une installation standard par défaut sur Linux, vous pouvez les trouver comme ceci -
tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> lsVous verrez des sous-répertoires comprenant (mais sans s'y limiter) les suivants -
- actionpack-x.y.z
- activerecord-x.y.z
- rails-x.y.z
Sur une installation Windows, vous pouvez les trouver comme ceci -
tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dirVous verrez des sous-répertoires comprenant (mais sans s'y limiter) les suivants -
ActionView et ActionController sont regroupés sous ActionPack.
ActiveRecord fournit une gamme de techniques de programmation et de raccourcis pour manipuler les données d'une base de données SQL. ActionController et ActionView fournissent des fonctionnalités pour manipuler et afficher ces données. Les rails relient tout ensemble.
Lorsque vous utilisez le script d'assistance Rails pour créer votre application, il crée toute la structure de répertoires de l'application. Rails sait où trouver les éléments dont il a besoin dans cette structure, vous n'avez donc pas à fournir de données.
Voici une vue de niveau supérieur d'une arborescence de répertoires créée par le script d'assistance au moment de la création de l'application. À l'exception des changements mineurs entre les versions, chaque projet Rails aura la même structure, avec les mêmes conventions de dénomination. Cette cohérence vous donne un énorme avantage; vous pouvez rapidement passer d'un projet Rails à un autre sans réapprendre l'organisation du projet.
Pour comprendre cette structure de répertoires, utilisons le demoapplication créée dans le chapitre Installation. Il peut être créé à l'aide d'une simple commande d'assistancerails demo.
Maintenant, allez dans le répertoire racine de l'application de démonstration comme suit -
tp> cd demo
demo> dirVous trouverez une structure de répertoires dans Windows comme suit -
Expliquons maintenant le but de chaque répertoire
app- Il organise les composants de votre application. Il contient des sous-répertoires contenant la vue (vues et assistants), le contrôleur (contrôleurs) et la logique métier du backend (modèles).
app/controllers- Le sous-répertoire des contrôleurs est l'endroit où Rails recherche les classes de contrôleurs. Un contrôleur gère une requête Web de l'utilisateur.
app/helpers- Le sous-répertoire helpers contient toutes les classes d'assistance utilisées pour assister les classes de modèle, de vue et de contrôleur. Cela permet de garder le modèle, la vue et le code du contrôleur petits, concentrés et épurés.
app/models- Le sous-répertoire models contient les classes qui modélisent et encapsulent les données stockées dans la base de données de notre application. Dans la plupart des frameworks, cette partie de l'application peut devenir assez désordonnée, fastidieuse, verbeuse et sujette aux erreurs. Les rails le rendent extrêmement simple!
app/view - Le sous-répertoire views contient les modèles d'affichage à remplir avec les données de notre application, à convertir en HTML et à revenir au navigateur de l'utilisateur.
app/view/layouts- Contient les fichiers modèles pour les mises en page à utiliser avec les vues. Cela modélise la méthode courante d'en-tête / pied de page pour habiller les vues. Dans vos vues, définissez une mise en page en utilisant <tt> layout: default </tt> et créez un fichier nommé default.html.erb. Dans default.html.erb, appelez <% yield%> pour rendre la vue en utilisant cette disposition.
components - Ce répertoire contient des composants, de petites applications autonomes qui regroupent le modèle, la vue et le contrôleur.
config- Ce répertoire contient la petite quantité de code de configuration dont votre application aura besoin, y compris la configuration de votre base de données (dans database.yml), la structure de votre environnement Rails (environment.rb) et le routage des requêtes Web entrantes (routes.rb). Vous pouvez également personnaliser le comportement des trois environnements Rails pour le test, le développement et le déploiement avec les fichiers trouvés dans le répertoire des environnements.
db- Habituellement, votre application Rails aura des objets modèle qui accèdent aux tables de base de données relationnelle. Vous pouvez gérer la base de données relationnelle avec les scripts que vous créez et placez dans ce répertoire.
doc- Ruby a un framework, appelé RubyDoc, qui peut générer automatiquement de la documentation pour le code que vous créez. Vous pouvez aider RubyDoc avec des commentaires dans votre code. Ce répertoire contient tous les Rails générés par RubyDoc et la documentation de l'application.
lib - Vous placerez des bibliothèques ici, à moins qu'elles n'appartiennent explicitement ailleurs (comme les bibliothèques de fournisseurs).
log- Les journaux d'erreurs vont ici. Rails crée des scripts qui vous aident à gérer divers journaux d'erreurs. Vous trouverez des journaux séparés pour le serveur (server.log) et chaque environnement Rails (development.log, test.log et production.log).
public - Comme le répertoire public d'un serveur Web, ce répertoire contient des fichiers Web qui ne changent pas, tels que des fichiers JavaScript (public / javascripts), des graphiques (public / images), des feuilles de style (public / stylesheets) et des fichiers HTML (public ).
script- Ce répertoire contient des scripts pour lancer et gérer les différents outils que vous utiliserez avec Rails. Par exemple, il existe des scripts pour générer du code (générer) et lancer le serveur Web (serveur).
test- Les tests que vous écrivez et ceux que Rails crée pour vous, tout va ici. Vous verrez un sous-répertoire pour les mocks (mocks), les tests unitaires (unit), les fixtures (fixtures) et les tests fonctionnels (fonctionnels).
tmp - Rails utilise ce répertoire pour contenir les fichiers temporaires pour un traitement intermédiaire.
vendor - Les bibliothèques fournies par des fournisseurs tiers (comme les bibliothèques de sécurité ou les utilitaires de base de données au-delà de la distribution de base de Rails) vont ici.
En dehors de ces répertoires, il y aura deux fichiers disponibles dans le répertoire de démonstration.
README - Ce fichier contient un détail de base sur l'application ferroviaire et une description de la structure de répertoire expliquée ci-dessus.
Rakefile- Ce fichier est similaire à Unix Makefile, qui aide à construire, empaqueter et tester le code Rails. Cela sera utilisé par l'utilitaire rake fourni avec l'installation de Ruby.
Dans ce chapitre, nous créerons un système de bibliothèque en ligne simple mais opérationnel pour conserver et gérer les livres.
Cette application a une architecture de base et sera construite à l'aide de deux modèles ActiveRecord pour décrire les types de données stockées -
- Livres, qui décrit une liste réelle.
- Sujet, utilisé pour regrouper les livres.
Flux de travail pour la création d'applications Rails
Un flux de travail recommandé pour créer une application Rails est le suivant:
Utilisez la commande rails pour créer le squelette de base de l'application.
Créez une base de données sur le serveur PostgreSQL pour contenir vos données.
Configurez l'application pour savoir où se trouve votre base de données et les informations de connexion correspondantes.
Créez des enregistrements actifs de rails (modèles), car ce sont les objets métier avec lesquels vous travaillerez dans vos contrôleurs.
Générez des migrations qui simplifient la création et la maintenance des tables et des colonnes de base de données.
Écrivez le code du contrôleur pour donner vie à votre application.
Créez des vues pour présenter vos données via l'interface utilisateur.
Alors, commençons par créer notre application de bibliothèque.
Création d'une application Web de rails vides
Rails est à la fois un cadre d'application Web d'exécution et un ensemble de scripts d'aide qui automatisent de nombreuses choses que vous faites lors du développement d'une application Web. Dans cette étape, nous utiliserons un tel script d'assistance pour créer la structure de répertoires entière et l'ensemble initial de fichiers pour démarrer notre application Library System.
Accédez au répertoire d'installation de ruby pour créer votre application.
Exécutez la commande suivante pour créer un squelette pour l'application de bibliothèque. Cela créera la structure de répertoires dans le répertoire courant.
tp> rails new libraryCela créera un sous-répertoire pour l'application de bibliothèque contenant une arborescence de répertoires complète de dossiers et de fichiers pour une application Rails vide. Vérifiez une structure de répertoire complète de l'application. Consultez la structure du répertoire Rails pour plus de détails.
La plupart de notre travail de développement consistera à créer et éditer des fichiers dans le library/appsous-répertoires. Voici un bref aperçu de leur utilisation -
Le sous-répertoire des contrôleurs est l'endroit où Rails recherche les classes de contrôleurs. Un contrôleur gère une requête Web de l'utilisateur.
Le sous-répertoire views contient les modèles d'affichage à remplir avec les données de notre application, à convertir en HTML et à revenir au navigateur de l'utilisateur.
Le sous-répertoire models contient les classes qui modélisent et encapsulent les données stockées dans la base de données de notre application. Dans la plupart des frameworks, cette partie de l'application peut devenir assez désordonnée, fastidieuse, verbeuse et sujette aux erreurs. Les rails le rendent très simple.
Le sous-répertoire helpers contient toutes les classes d'assistance utilisées pour assister les classes de modèle, de vue et de contrôleur. Cela permet de garder le modèle, la vue et le code du contrôleur petits, concentrés et épurés.
Démarrage du serveur Web
L'application Web Rails peut s'exécuter sous pratiquement n'importe quel serveur Web, mais le moyen le plus pratique de développer une application Web Rails est d'utiliser le serveur Web WEBrick intégré. Commençons ce serveur Web, puis parcourons notre application de bibliothèque vide -
Ce serveur sera démarré à partir du répertoire d'application comme suit. Il fonctionne sur le port numéro 3000.
tp> cd ruby\library
tp\ruby\library\> Rails serverIl génère le code automatique pour démarrer le serveur comme indiqué ci-dessous -
Cela démarrera votre serveur Web WEBrick.
Ouvrez maintenant votre navigateur et accédez à http://127.0.0.1:3000. Si tout va bien, vous devriez voir un message d'accueil de WEBrick, sinon il y a un problème avec votre réglage. Si tout se passe bien, le résultat sera généré comme suit.
Quelle est la prochaine?
Le chapitre suivant explique comment créer des bases de données pour votre application et quelle est la configuration requise pour accéder à ces bases de données créées.
De plus, nous verrons ce qu'est la migration Rails et comment elle est utilisée pour maintenir les tables de base de données.
Avant de commencer avec ce chapitre, assurez-vous que votre serveur de base de données est opérationnel. Ruby on Rails recommande de créer trois bases de données - une base de données pour chaque environnement de développement, de test et de production. Selon la convention, leurs noms devraient être -
- library_development
- library_production
- library_test
Vous devez les initialiser tous les trois et leur créer un utilisateur et un mot de passe avec tous les privilèges de lecture et d'écriture. Nous utilisons leroot ID utilisateur de notre application.
Configuration de la base de données pour MySQL
Dans MySQL, nous utilisons le rootID utilisateur de notre application. La session de console MySQL dans laquelle vous faites cela ressemble à quelque chose comme -
mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)
mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)Vous pouvez faire la même chose pour deux autres bases de données library_production et library_test.
Configuration de database.yml
À ce stade, vous devez informer Rails du nom d'utilisateur et du mot de passe des bases de données. Vous faites cela dans le fichierdatabase.yml, disponible dans le library\configsous-répertoire de l'application Rails que vous avez créé. Ce fichier contient des sections de configuration en direct pour les bases de données MySQL. Dans chacune des sections que vous utilisez, vous devez modifier les lignes de nom d'utilisateur et de mot de passe pour refléter les autorisations sur les bases de données que vous avez créées.
Lorsque vous avez terminé, cela devrait ressembler à quelque chose comme -
development:
adapter: mysql
database: library_development
username: root
password: [password]
host: localhost
test:
adapter: mysql
database: library_test
username: root
password: [password]
host: localhost
production:
adapter: mysql
database: library_production
username: root
password: [password]
host: localhostConfiguration de la base de données pour PostgreSQL
Par défaut, PostgreSQL ne fournit aucun utilisateur. Nous devons créer de nouveaux utilisateurs. Utilisez la commande suivante pour créer un utilisateur avec le nomrubyuser.
tp> sudo -u postgres createuser rubyuser -sSi vous souhaitez créer un mot de passe pour le nouvel utilisateur, utilisez la commande suivante.
tp> sudo -u postgres psql
postgres=# \password rubyuserUtilisez la commande suivante pour créer une base de données library_development.
postgres=# CREATE DATABASE library_development OWNER rubyuser;
CREATE DATABASEUtilisez la commande suivante pour créer une base de données library_production.
postgres=# CREATE DATABASE library_production OWNER rubyuser;
CREATE DATABASEUtilisez la commande suivante pour créer une base de données library_test.
postgres=# CREATE DATABASE library_test OWNER rubyuser;
CREATE DATABASEpresse Ctrl+D pour terminer PosgreSQL.
Configuration de database.yml
À ce stade, vous devez indiquer à Rails le nom d'utilisateur et le mot de passe des bases de données. Vous faites cela dans le fichierdatabase.yml, disponible dans le library\configsous-répertoire de l'application Rails que vous avez créé. Ce fichier contient des sections de configuration en direct pour les bases de données PostgreSQL. Dans chacune des sections, vous devez modifier les lignes de nom d'utilisateur et de mot de passe pour refléter les autorisations sur les bases de données que vous avez créées.
Lorsque vous avez terminé, cela devrait ressembler à ceci -
default: &default
adapter: postgresql
encoding: unicode
development:
adapter: postgresql
encoding: unicode
database: library_development
username: rubyuser
password: <Password for rubyuser>
test:
adapter: postgresql
encoding: unicode
database: library_test
username: rubyuser
password: <Password for rubyuser>
production:
adapter: postgresql
encoding: unicode
database: library_production
username: rubyuser
password: <Password for rubyuser>Quelle est la prochaine?
Les deux chapitres suivants expliquent comment modéliser vos tables de base de données et comment gérer celles qui utilisent les migrations Rails.
L'enregistrement actif Rails est la couche ORM (Object / Relational Mapping) fournie avec Rails. Il suit de près le modèle ORM standard, qui est le suivant -
- les tables correspondent aux classes,
- les lignes correspondent aux objets et
- les colonnes correspondent aux attributs d'objet.
Les enregistrements actifs de Rails fournissent une interface et une liaison entre les tables d'une base de données relationnelle et le code du programme Ruby qui manipule les enregistrements de la base de données. Les noms de méthode Ruby sont automatiquement générés à partir des noms de champ des tables de base de données.
Chaque objet Active Record a CRUD (Ccréer, Read, Update, et Delete) méthodes d'accès à la base de données. Cette stratégie permet des conceptions simples et des mappages directs entre les tables de base de données et les objets d'application.
Traduire un modèle de domaine en SQL
La traduction d'un modèle de domaine en SQL est généralement simple, tant que vous vous souvenez que vous devez écrire du SQL compatible Rails. Concrètement, vous devez suivre certaines règles -
Chaque entité (comme un livre) obtient une table dans la base de données qui porte son nom, mais au pluriel (livres).
Chacune de ces tables de correspondance d'entités a un champ appelé id , qui contient un entier unique pour chaque enregistrement inséré dans la table.
Étant donné l'entité x et l'entité y, si l'entité y appartient à l'entité x, alors la table y a un champ appelé x_id.
La majorité des champs de n'importe quelle table stockent les valeurs des propriétés simples de cette entité (tout ce qui est un nombre ou une chaîne).
Création de fichiers d'enregistrement actifs (modèles)
Pour créer les fichiers Active Record pour nos entités pour l'application de bibliothèque, introduits dans le chapitre précédent, exécutez la commande suivante à partir du niveau supérieur du répertoire de l'application.
library\> ruby script/generate model Book
library\> ruby script/generate model SubjectAu dessus de rails generate model book commandes génère le code automatique comme ci-dessous -
Vous dites au générateur de créer des modèles appelés Livre et Sujet pour stocker des instances de livres et de sujets. Notez que vous mettez en majuscule Livre et Sujet et utilisez la forme singulière. Il s'agit d'un paradigme Rails que vous devez suivre chaque fois que vous créez un modèle.
Lorsque vous utilisez l'outil de génération, Rails crée le fichier de modèle réel contenant toutes les méthodes propres au modèle et les règles métier que vous définissez, un fichier de test unitaire pour effectuer un développement piloté par les tests, un exemple de fichier de données (appelé fixtures) à utiliser avec les tests unitaires et une migration Rails qui facilite la création de tables et de colonnes de base de données.
Outre la création de nombreux autres fichiers et répertoires, cela créera des fichiers nommés book.rb et subject.rb contenant une définition de squelette dans le app/models annuaire.
Contenu disponible dans book.rb -
class Book < ActiveRecord::Base
endContenu disponible dans subject.rb -
class Subject < ActiveRecord::Base
endCréation d'associations entre modèles
Lorsque vous avez plus d'un modèle dans votre application de rails, vous devez créer une connexion entre ces modèles. Vous pouvez le faire via des associations. Active Record prend en charge trois types d'associations -
one-to-one- Une relation un-à-un existe lorsqu'un élément a exactement un élément d'un autre. Par exemple, une personne a exactement un anniversaire ou un chien a exactement un propriétaire.
one-to-many- Une relation un-à-plusieurs existe lorsqu'un seul objet peut être membre de nombreux autres objets. Par exemple, un sujet peut avoir plusieurs livres.
many-to-many - Une relation plusieurs-à-plusieurs existe lorsque le premier objet est lié à un ou plusieurs d'un deuxième objet et que le second objet est lié à un ou plusieurs des premiers objets.
Vous indiquez ces associations en ajoutant des déclarations à vos modèles: has_one, has_many, comes_to et has_and_belongs_to_many.
Vous devez maintenant indiquer à Rails les relations que vous souhaitez établir dans le système de données de la bibliothèque. Pour ce faire, modifiez book.rb et subject.rb pour qu'ils ressemblent à ceci -
class Book < ActiveRecord::Base
belongs_to :subject
endNous avons utilisé un sujet singulier dans l'exemple ci-dessus, car un livre peut appartenir à un seul sujet.
class Subject < ActiveRecord::Base
has_many :books
endNous avons utilisé ici plusieurs livres, car un sujet peut avoir plusieurs livres.
Implémentation de validations sur des modèles
L'implémentation des validations se fait dans un modèle Rails. Les données que vous entrez dans la base de données sont définies dans le modèle Rails réel, il est donc logique de définir ce que les données valides impliquent au même emplacement.
Les validations sont -
La valeur du champ de titre ne doit pas être NULL.
La valeur du champ de prix doit être numérique.
Ouvert book.rb dans le app\model sous-répertoire et mettez les validations suivantes -
class Book < ActiveRecord::Base
belongs_to :subject
validates_presence_of :title
validates_numericality_of :price, :message=>"Error Message"
endvalidates_presence_of - protège les champs "NOT NULL" contre les entrées utilisateur manquantes.
validates_numericality_of - empêche l'utilisateur de saisir des données non numériques.
Outre les validations mentionnées ci-dessus, il existe d'autres validations communes. Consultez le guide rapide des rails .
Quelle est la prochaine?
Dans le chapitre suivant, nous apprendrons Rails Migration, qui vous permet d'utiliser Ruby pour définir les modifications de votre schéma de base de données, ce qui permet d'utiliser un système de contrôle de version pour garder les choses synchronisées avec le code réel.
Rails Migration vous permet d'utiliser Ruby pour définir les modifications de votre schéma de base de données, ce qui permet d'utiliser un système de contrôle de version pour garder les choses synchronisées avec le code réel.
Cela a de nombreuses utilisations, y compris -
Teams of developers - Si une personne fait un changement de schéma, les autres développeurs ont juste besoin de mettre à jour et d'exécuter "rake migrate".
Production servers - Exécutez "rake migrate" lorsque vous déployez une nouvelle version pour mettre également la base de données à jour.
Multiple machines - Si vous développez à la fois sur un ordinateur de bureau et un ordinateur portable, ou à plusieurs endroits, les migrations peuvent vous aider à les maintenir toutes synchronisées.
Que peut faire la migration Rails?
- create_table (nom, options)
- drop_table(name)
- rename_table (ancien_nom, nouveau_nom)
- add_column (nom_table, nom_colonne, type, options)
- rename_column (nom_table, nom_colonne, nouveau_nom_colonne)
- change_column (nom_table, nom_colonne, type, options)
- remove_column (nom_table, nom_colonne)
- add_index (nom_table, nom_colonne, type_index)
- remove_index (nom_table, nom_colonne)
Migrations support all the basic data types - Voici la liste des types de données pris en charge par la migration -
string - pour les petits types de données comme un titre.
text - pour de plus longs morceaux de données textuelles, comme la description.
integer - pour les nombres entiers.
float - pour les décimales.
datetime and timestamp - stocker la date et l'heure dans une colonne.
date and time - stocker la date uniquement ou l'heure uniquement.
binary - pour stocker des données telles que des images, de l'audio ou des films.
Boolean - pour stocker des valeurs vraies ou fausses.
Valid column options are - Voici la liste des options de colonne valides.
limit (: limite => "50")
default (: default => "bla")
null(: null => false implique NOT NULL )
NOTE - Les activités effectuées par Rails Migration peuvent être effectuées à l'aide de n'importe quelle interface graphique frontale ou directement sur l'invite SQL, mais Rails Migration rend toutes ces activités très faciles.
Consultez l' API Rails pour plus de détails à ce sujet.
Créer les migrations
Voici la syntaxe générique pour créer une migration -
application_dir> rails generate migration table_nameCela créera le fichier db / migrate / 001_table_name.rb. Un fichier de migration contient la syntaxe Ruby de base qui décrit la structure de données d'une table de base de données.
NOTE - Avant d'exécuter le générateur de migration, il est recommandé de nettoyer les migrations existantes générées par les générateurs de modèles.
Nous allons créer deux migrations correspondant à nos trois tables - books and subjects.
La migration des livres doit être la suivante -
tp> cd library
library> rails generate migration booksLa commande ci-dessus génère le code suivant.
la migration des sujets devrait être la suivante -
tp> cd library
library> rails generate migration subjectsLa commande ci-dessus génère le code suivant.
Notez que vous utilisez des minuscules pour le livre et le sujet et le pluriel lors de la création de migrations. Il s'agit d'un paradigme Rails que vous devez suivre chaque fois que vous créez une migration.
Modifier le code
Accédez au sous-répertoire db / migrate de votre application et modifiez chaque fichier un par un à l'aide d'un simple éditeur de texte.
Modifiez 001_books.rb comme suit -
La colonne ID sera créée automatiquement, alors ne le faites pas ici également.
class Books < ActiveRecord::Migration
def self.up
create_table :books do |t|
t.column :title, :string, :limit => 32, :null => false
t.column :price, :float
t.column :subject_id, :integer
t.column :description, :text
t.column :created_at, :timestamp
end
end
def self.down
drop_table :books
end
endLa méthode self.up est utilisé lors de la migration vers une nouvelle version, self.downest utilisé pour annuler les modifications si nécessaire. À ce moment, le script ci-dessus sera utilisé pour créerbooks table.
Modifiez 002_subjects.rb comme suit -
class Subjects < ActiveRecord::Migration
def self.up
create_table :subjects do |t|
t.column :name, :string
end
Subject.create :name => "Physics"
Subject.create :name => "Mathematics"
Subject.create :name => "Chemistry"
Subject.create :name => "Psychology"
Subject.create :name => "Geography"
end
def self.down
drop_table :subjects
end
endLe script ci-dessus sera utilisé pour créer subjects table et créera cinq enregistrements dans la table des sujets.
Exécutez la migration
Maintenant que vous avez créé tous les fichiers de migration requis. Il est temps de les exécuter sur la base de données. Pour ce faire, accédez à une invite de commande et accédez au répertoire de la bibliothèque dans lequel se trouve l'application, puis tapezrake migrate comme suit -
library> rake db:migrateCela créera une table "schema_info" si elle n'existe pas, qui suit la version actuelle de la base de données - chaque nouvelle migration sera une nouvelle version et toutes les nouvelles migrations seront exécutées jusqu'à ce que votre base de données soit à la version actuelle.
Rakeest un programme de construction Ruby similaire au programme Unix make dont Rails profite pour simplifier l'exécution de tâches complexes telles que la mise à jour de la structure d'une base de données, etc.
Exécution de migrations pour les bases de données de production et de test
Si vous souhaitez spécifier l'environnement Rails à utiliser pour la migration, utilisez la variable shell RAILS_ENV.
Par exemple -
library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrateNOTE- Sous Windows, utilisez "set RAILS_ENV = production" au lieu de la commande d' exportation .
Quelle est la prochaine?
Nous avons maintenant notre base de données et les tables requises disponibles. Dans les deux chapitres suivants, nous explorerons deux composants importants appelés Controller (ActionController) et View (ActionView).
Création de contrôleurs (contrôleur d'action).
Création de vues (vue Action).
Le contrôleur Rails est le centre logique de votre application. Il coordonne l'interaction entre l'utilisateur, les vues et le modèle. Le contrôleur héberge également un certain nombre de services auxiliaires importants.
Il est responsable de l'acheminement des requêtes externes vers les actions internes. Il gère extrêmement bien les URL conviviales.
Il gère la mise en cache, ce qui peut améliorer les performances des applications.
Il gère les modules d'assistance, qui étendent les capacités des modèles de vue sans gonfler leur code.
Il gère les sessions, donnant aux utilisateurs l'impression d'une interaction continue avec nos applications.
Le processus de création d'un contrôleur est très simple et il est similaire au processus que nous avons déjà utilisé pour créer un modèle. Nous allons créer un seul contrôleur ici -
library\> rails generate controller BookNotez que vous mettez Book en majuscule et que vous utilisez la forme singulière. Il s'agit d'un paradigme Rails que vous devez suivre chaque fois que vous créez un contrôleur.
Cette commande accomplit plusieurs tâches, dont les suivantes sont pertinentes ici -
Il crée un fichier appelé app/controllers/book_controller.rb
Si vous regardez book_controller.rb, vous le trouverez comme suit -
class BookController < ApplicationController
endLes classes de contrôleur héritent d' ApplicationController, qui est l'autre fichier dans le dossier des contrôleurs:application.rb.
L' ApplicationController contient du code qui peut être exécuté dans tous vos contrôleurs et hérite de la classe Rails ActionController :: Base .
Vous n'avez pas besoin de vous inquiéter avec ApplicationController pour le moment, définissons donc simplement quelques stubs de méthode dansbook_controller.rb. En fonction de vos besoins, vous pouvez définir n'importe quel nombre de fonctions dans ce fichier.
Modifiez le fichier pour qu'il ressemble à ce qui suit et enregistrez vos modifications. Notez que c'est à vous de choisir le nom que vous souhaitez donner à ces méthodes, mais mieux vaut donner des noms pertinents.
class BookController < ApplicationController
def list
end
def show
end
def new
end
def create
end
def edit
end
def update
end
def delete
end
endMaintenant, implémentons toutes les méthodes une par une.
Implémentation de la méthode list
La méthode list vous donne une liste de tous les livres de la base de données. Cette fonctionnalité sera réalisée par les lignes de code suivantes. Modifiez les lignes suivantes dans le fichier book_controller.rb.
def list
@books = Book.all
endLa ligne @books = Book.all de la méthode list indique à Rails de rechercher la table books et de stocker chaque ligne trouvée dans l'objet d'instance @books.
Implémentation de la méthode show
La méthode show n'affiche que des détails supplémentaires sur un seul livre. Cette fonctionnalité sera réalisée par les lignes de code suivantes.
def show
@book = Book.find(params[:id])
endLa ligne @book = Book.find (params [: id]) de la méthode show indique à Rails de ne trouver que le livre dont l'ID est défini dans params [: id].
L'objet params est un conteneur qui vous permet de transmettre des valeurs entre les appels de méthode. Par exemple, lorsque vous êtes sur la page appelée par la méthode list, vous pouvez cliquer sur un lien pour un livre spécifique, et il transmet l'ID de ce livre via l'objet params afin que show puisse trouver le livre spécifique.
Mettre en œuvre la nouvelle méthode
La nouvelle méthode informe Rails que vous allez créer un nouvel objet. Alors ajoutez simplement le code suivant dans cette méthode.
def new
@book = Book.new
@subjects = Subject.all
endLa méthode ci-dessus sera appelée lorsque vous afficherez une page à l'utilisateur pour qu'il accepte les entrées de l'utilisateur. Ici, la deuxième ligne saisit tous les sujets de la base de données et les place dans un tableau appelé @subjects.
Implémentation de la méthode create
Une fois que vous prenez l'entrée utilisateur à l'aide du formulaire HTML, il est temps de créer un enregistrement dans la base de données. Pour ce faire, modifiez la méthode create dans le book_controller.rb pour qu'elle corresponde à ce qui suit -
def create
@book = Book.new(book_params)
if @book.save
redirect_to :action => 'list'
else
@subjects = Subject.all
render :action => 'new'
end
end
def book_params
params.require(:books).permit(:title, :price, :subject_id, :description)
endLa première ligne crée une nouvelle variable d'instance appelée @book qui contient un objet Book construit à partir des données soumises par l'utilisateur. lebook_params méthode est utilisée pour collecter tous les champs de l'objet :books. Les données ont été transmises à partir de la nouvelle méthode pour créer à l'aide de l'objet params.
La ligne suivante est une instruction conditionnelle qui redirige l'utilisateur vers le listméthode si l'objet est correctement enregistré dans la base de données. S'il ne sauvegarde pas, l'utilisateur est renvoyé vers la nouvelle méthode. La méthode redirect_to est similaire à l'exécution d'un méta-rafraîchissement sur une page Web: elle vous redirige automatiquement vers votre destination sans aucune interaction de l'utilisateur.
Ensuite, @subjects = Subject.all est requis au cas où il ne sauvegarde pas les données avec succès et cela devient le cas similaire à celui d'une nouvelle option.
Implémentation de la méthode d'édition
La méthode d'édition est presque identique à la méthode show. Les deux méthodes sont utilisées pour récupérer un seul objet en fonction de son identifiant et l'afficher sur une page. La seule différence est que la méthode show n'est pas modifiable.
def edit
@book = Book.find(params[:id])
@subjects = Subject.all
endCette méthode sera appelée pour afficher des données sur l'écran à modifier par l'utilisateur. La deuxième ligne saisit tous les sujets de la base de données et les place dans un tableau appelé @subjects.
Implémentation de la méthode de mise à jour
Cette méthode sera appelée après la méthode d'édition, lorsque l'utilisateur modifie une donnée et souhaite mettre à jour les modifications dans la base de données. La méthode de mise à jour est similaire à la méthode de création et sera utilisée pour mettre à jour les livres existants dans la base de données.
def update
@book = Book.find(params[:id])
if @book.update_attributes(book_param)
redirect_to :action => 'show', :id => @book
else
@subjects = Subject.all
render :action => 'edit'
end
end
def book_param
params.require(:book).permit(:title, :price, :subject_id, :description)
endLa méthode update_attributes est similaire à la méthode save utilisée par create mais au lieu de créer une nouvelle ligne dans la base de données, elle écrase les attributs de la ligne existante.
Ensuite, la ligne @subjects = Subject.all est requise au cas où elle ne sauvegarde pas les données avec succès, elle devient similaire à l'option d'édition.
Implémentation de la méthode de suppression
Si vous souhaitez supprimer un enregistrement de la base de données, vous utiliserez cette méthode. Implémentez cette méthode comme suit.
def delete
Book.find(params[:id]).destroy
redirect_to :action => 'list'
endLa première ligne trouve le classifié en fonction du paramètre passé via l'objet params, puis le supprime à l'aide de la méthode destroy. La deuxième ligne redirige l'utilisateur vers la méthode list à l'aide d'un appel redirect_to.
Méthodes supplémentaires pour afficher les sujets
Supposons que vous souhaitiez donner à vos utilisateurs la possibilité de parcourir tous les livres en fonction d'un sujet donné. Ainsi, vous pouvez créer une méthode dans book_controller.rb pour afficher tous les sujets. Supposons que le nom de la méthode estshow_subjects -
def show_subjects
@subject = Subject.find(params[:id])
endEnfin votre book_controller.rb le fichier ressemblera à ceci -
class BooksController < ApplicationController
def list
@books = Book.all
end
def show
@book = Book.find(params[:id])
end
def new
@book = Book.new
@subjects = Subject.all
end
def book_params
params.require(:books).permit(:title, :price, :subject_id, :description)
end
def create
@book = Book.new(book_params)
if @book.save
redirect_to :action => 'list'
else
@subjects = Subject.all
render :action => 'new'
end
end
def edit
@book = Book.find(params[:id])
@subjects = Subject.all
end
def book_param
params.require(:book).permit(:title, :price, :subject_id, :description)
end
def update
@book = Book.find(params[:id])
if @book.update_attributes(book_param)
redirect_to :action => 'show', :id => @book
else
@subjects = Subject.all
render :action => 'edit'
end
end
def delete
Book.find(params[:id]).destroy
redirect_to :action => 'list'
end
def show_subjects
@subject = Subject.find(params[:id])
end
endMaintenant, enregistrez votre fichier de contrôleur.
Quelle est la prochaine?
Vous avez créé presque toutes les méthodes, qui fonctionneront sur le backend. Ensuite, nous définirons des routes (URL) pour les actions.
Le module de routage fournit la réécriture d'URL en Ruby natif. C'est un moyen de rediriger les demandes entrantes vers les contrôleurs et les actions. Il remplace les règles mod_rewrite. Mieux encore, le routage de Rails fonctionne avec n'importe quel serveur Web. Les itinéraires sont définis dans app / config / routes.rb.
Pensez à créer des itinéraires comme à dessiner une carte pour vos demandes. La carte leur indique où aller en fonction d'un modèle prédéfini -
Rails.application.routes.draw do
Pattern 1 tells some request to go to one place
Pattern 2 tell them to go to another
...
endExemple
Considérons que notre application de gestion de bibliothèque contient un contrôleur appelé BookController. Nous devons définir les routes pour ces actions qui sont définies comme des méthodes dans la classe BookController.
Ouvrez le fichier routes.rb dans le répertoire library / config / et modifiez-le avec le contenu suivant.
Rails.application.routes.draw do
get 'book/list'
get 'book/new'
post 'book/create'
patch 'book/update'
get 'book/list'
get 'book/show'
get 'book/edit'
get 'book/delete'
get 'book/update'
get 'book/show_subjects'
endLe fichier routes.rb définit les actions disponibles dans les applications et le type d'action tel que get, post et patch.
Utilisez la commande suivante pour répertorier toutes vos routes définies, qui sont utiles pour détecter les problèmes de routage dans votre application ou pour vous donner un bon aperçu des URL dans une application avec laquelle vous essayez de vous familiariser.
library> rake routesQuelle est la prochaine?
Ensuite, nous allons créer le code pour générer des écrans pour afficher les données et pour prendre les entrées de l'utilisateur.
Une vue Rails est un programme ERb qui partage des données avec les contrôleurs via des variables accessibles mutuellement.
Si vous regardez dans le répertoire app / views de l'application de la bibliothèque, vous verrez un sous-répertoire pour chacun des contrôleurs, nous avons créé: book. Chacun de ces sous-répertoires a été créé automatiquement lorsque le contrôleur du même nom a été créé avec le script de génération.
Les rails vous indiquent que vous devez créer le fichier de vue pour chaque nouvelle méthode. Chaque méthode que vous définissez dans le contrôleur doit avoir unerb fichier, portant le même nom que la méthode, pour afficher les données collectées par la méthode.
Créons donc des fichiers de vue pour toutes les méthodes que nous avons définies dans le book_controller.rb. Lors de l'exécution de ces vues, vérifiez simultanément que ces actions sont applicables ou non dans la base de données.
Création d'un fichier de vue pour la méthode de liste
Créez un fichier appelé list.html.erben utilisant votre éditeur de texte préféré et enregistrez-le dans l'application / vues / livre. Après avoir créé et enregistré le fichier, actualisez votre navigateur Web. Vous devriez voir une page vierge; si vous ne le faites pas, vérifiez l'orthographe de votre fichier et assurez-vous qu'il correspond exactement à la méthode de votre contrôleur.
Maintenant, affichez le contenu réel. Mettons le code suivant dans list.html.erb.
<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>
<ul id = "books">
<% @books.each do |c| %>
<li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
<% end %>
</ul>
<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>Le code à exécuter consiste à vérifier si le tableau @books contient des objets. le.blank?La méthode retourne true si le tableau est vide et false s'il contient des objets. Cet objet @books a été créé dans le contrôleur à l'intérieur de la méthode list.
Le code entre les balises <% =%> est un link_toappel de méthode. Le premier paramètre de link_to est le texte à afficher entre les balises <a>. Le deuxième paramètre est quelle action est appelée lorsque le lien est cliqué. Dans ce cas, c'est la méthode show. Le paramètre final est l'id du livre qui est passé via l'objet params.
Maintenant, essayez d'actualiser votre navigateur et vous devriez obtenir l'écran suivant car nous n'avons aucun livre dans notre bibliothèque.
Création d'un fichier de vue pour une nouvelle méthode
Jusqu'à présent, nous n'avons aucun livre dans notre bibliothèque. Nous devons créer peu de livres dans le système. Alors, concevons une vue correspondant à lanew méthode définie dans le book_controller.rb.
Créez un fichier appelé new.html.erb à l'aide de votre éditeur de texte préféré et enregistrez-le dans app / views / book. Ajoutez le code suivant au fichier new.html.erb.
<h1>Add new book</h1>
<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:
<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:
<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:
<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>
<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>
<% end -%>
<%= link_to 'Back', {:action => 'list'} %>Ici form_tagLa méthode interprète le code Ruby dans une balise HTML <form> régulière en utilisant toutes les informations qui lui sont fournies. Cette balise, par exemple, génère le code HTML suivant -
<form action = "/book/create" method = "post">La méthode suivante est text_fieldqui génère un champ de texte <input>. Les paramètres de text_field sont l'objet et le nom du champ. Dans ce cas, l'objet est livre et le nom est titre .
Méthode Rails appelée collection_select, crée un menu de sélection HTML construit à partir d'un tableau, tel que celui de @books. Il y a cinq paramètres, qui sont les suivants -
:book - L'objet que vous manipulez. Dans ce cas, c'est un objet livre.
:subject_id - Le champ qui est rempli lorsque le livre est enregistré.
@books - La baie avec laquelle vous travaillez.
:id- La valeur stockée dans la base de données. En termes de HTML, il s'agit du paramètre de valeur de la balise <option>.
:name- La sortie que l'utilisateur voit dans le menu déroulant. Il s'agit de la valeur entre les balises <option>.
Le prochain utilisé est submit_tag, qui génère un bouton <input> qui soumet le formulaire. Enfin, il y a leend méthode qui se traduit simplement par </form>.
Accédez à votre navigateur et visitez http://localhost:3000/book/new. Cela vous donnera l'écran suivant.
Entrez des données dans ce formulaire, puis cliquez sur le bouton Créer. Ici, j'ai ajouté les détails suivants dans les champs -
Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new bookLorsque vous cliquez sur le Create bouton, il appellera le create méthode, qui n'a besoin d'aucune vue car cette méthode utilise soit list ou newméthodes pour afficher les résultats. Ainsi, lorsque vous cliquez sur le bouton Créer, les données doivent être soumises avec succès et vous rediriger vers la page de liste, dans laquelle vous avez maintenant un seul élément répertorié comme suit -
Si vous cliquez sur le lien, vous devriez voir une autre erreur de modèle manquant, car vous n'avez pas encore créé le fichier de modèle pour la méthode show.
Création d'un fichier de vue pour la méthode show
Cette méthode affichera le détail complet de tout livre disponible dans la bibliothèque. Créez un fichier show.html.erb sous app / views / book et remplissez-le avec le code suivant -
<h1><%= @book.title %></h1>
<p>
<strong>Price: </strong> $<%= @book.price %><br />
<strong>Subject :</strong> <%= @book.subject.name %><br />
<strong>Created Date:</strong> <%= @book.created_at %><br />
</p>
<p><%= @book.description %></p>
<hr />
<%= link_to 'Back', {:action => 'list'} %>C'est la première fois que vous tirez pleinement parti des associations, qui vous permettent d'extraire facilement des données d'objets associés.
Le format utilisé est @variable.relatedObject.column. Dans ce cas, vous pouvez extraire la valeur du nom du sujet via la variable @book à l'aide dubelongs_toles associations. Si vous cliquez sur un enregistrement répertorié, l'écran suivant s'affiche.
Création d'un fichier de vue pour la méthode d'édition
Créez un nouveau fichier appelé edit.html.erb et enregistrez-le dans app / views / book. Remplissez-le avec le code suivant -
<h1>Edit Book Detail</h1>
<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>
<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field 'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>
<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>
<%= link_to 'Back', {:action => 'list' } %>Ce code est très similaire au new méthode sauf action à mettre à jour au lieu de créer et de définir un identifiant.
Dans ce scénario, nous avons utilisé form_forbalise pour l'action de formulaire. Il fonctionnera mieux queform_tag. Pourquoi parce qu'il créera facilement une interaction avec le modèle. Par conséquent, il est préférable d'utiliser la balise form_for chaque fois que vous avez besoin d'une interaction entre le modèle et les champs du formulaire.
À ce stade, nous avons besoin de quelques modifications dans le list method'sVoir la fiche. Accédez à l'élément <li> </li> et modifiez-le pour qu'il ressemble à ce qui suit -
<li>
<%= link_to c.title, {:action => "show", :id => c.id} -%>
<b> <%= link_to 'Edit', {:action => "edit",
:id => c.id} %></b>
</li>Maintenant, essayez de parcourir les livres en utilisant le http://localhost:3000/book/list. Il vous donnera la liste de tous les livres avec Editoption. Lorsque vous cliquez sur l'option Modifier, vous aurez l'écran suivant comme suit -
Maintenant, vous modifiez ces informations, puis cliquez sur le bouton Enregistrer les modifications . Cela entraînera un appel àupdateméthode disponible dans le fichier du contrôleur et il mettra à jour tous les attributs modifiés. Notez que leupdate n'a pas besoin de fichier de vue car elle utilise soit show ou edit méthodes pour montrer ses résultats.
Création d'un fichier de vue pour la méthode de suppression
Supprimer des informations d'une base de données à l'aide de Ruby on Rails est presque trop facile. Vous n'avez pas besoin d'écrire de code de vue pour la méthode de suppression car cette méthode utiliselistméthode pour afficher le résultat. Alors, modifions à nouveau list.html.erb et ajoutons un lien de suppression.
Accédez à l'élément <li> </li> et modifiez-le pour qu'il ressemble à ce qui suit -
<li>
<%= link_to c.title, {:action => 'show', :id => c.id} -%>
<b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
<b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
:confirm => "Are you sure you want to delete this item?" %></b>
</li>le :confirmLe paramètre présente une boîte de confirmation JavaScript vous demandant si vous voulez vraiment exécuter l'action. Si l'utilisateur clique sur OK, l'action se poursuit et l'élément est supprimé.
Maintenant, essayez de parcourir les livres en utilisant http://localhost:3000/book/list. Il vous donnera la liste de tous les livres avec Edit et Delete options comme suit -
Maintenant, en utilisant l'option Supprimer, vous pouvez supprimer n'importe quel enregistrement répertorié.
Création d'un fichier de vue pour la méthode show_subjects
Créez un nouveau fichier, show_subjects.html.erb, dans le répertoire app / views / book et ajoutez-y le code suivant -
<h1><%= @subject.name -%></h1>
<ul>
<% @subject.books.each do |c| %>
<li><%= link_to c.title, :action => "show", :id => c.id -%></li>
<% end %>
</ul>Vous tirez parti des associations en parcourant les nombreuses listes de livres d'un seul sujet.
Modifiez maintenant la ligne Subject: de show.html.erb afin que la liste des sujets affiche un lien.
<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />Cela affichera une liste de sujets sur la page d'index, afin que les utilisateurs puissent y accéder directement.
Modifier list.html.erb pour ajouter ce qui suit en haut du fichier -
<ul id = "subjects">
<% Subject.find(:all).each do |c| %>
<li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
<% end %>
</ul>Maintenant, essayez de parcourir les livres en utilisant http: // localhost: 3000 / book / list. Il affichera tous les sujets avec des liens afin que vous puissiez parcourir tous les livres liés à ce sujet.
Quelle est la prochaine?
J'espère maintenant que vous vous sentez à l'aise avec toutes les opérations de Rails.
Le chapitre suivant explique comment utiliser Layoutspour mettre vos données d'une meilleure manière. Nous allons vous montrer comment utiliser CSS dans vos applications Rails.
Une mise en page définit l'environnement d'une page HTML. C'est l'endroit pour définir un aspect et une sensation communs de votre sortie finale. Les fichiers de mise en page résident dans app / vues / mises en page.
Le processus consiste à définir un modèle de mise en page, puis à informer le contrôleur de son existence et à l'utiliser. Commençons par créer le modèle.
Ajoutez un nouveau fichier appelé standard.html.erb à app / views / layouts. Vous indiquez aux contrôleurs quel modèle utiliser par le nom du fichier, il est donc conseillé de suivre le même schéma de dénomination.
Ajoutez le code suivant au nouveau fichier standard.html.erb et enregistrez vos modifications -
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
<meta http-equiv = "Content-Language" content = "en-us" />
<title>Library Info System</title>
<%= stylesheet_link_tag "style" %>
</head>
<body id = "library">
<div id = "container">
<div id = "header">
<h1>Library Info System</h1>
<h3>Library powered by Ruby on Rails</h3>
</div>
<div id = "content">
<%= yield -%>
</div>
<div id = "sidebar"></div>
</div>
</body>
</html>Tout ce que vous venez d'ajouter était des éléments HTML standard à l'exception de deux lignes. lestylesheet_link_tagLa méthode helper génère une feuille de style <link>. Dans cet exemple, nous lions la feuille de style style.css. leyield La commande permet à Rails de savoir qu'elle doit mettre le html.erb pour la méthode appelée ici.
Ouvert book_controller.rb et ajoutez la ligne suivante juste en dessous de la première ligne -
class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................Il indique au contrôleur que nous voulons utiliser une mise en page disponible dans le fichier standard.html.erb. Maintenant, essayez de parcourir les livres qui produiront l'écran suivant.
Ajouter une feuille de style
Jusqu'à présent, nous n'avons créé aucune feuille de style, donc Rails utilise la feuille de style par défaut. Créons maintenant un nouveau fichier appelé style.css et sauvegardons-le dans / public / stylesheets. Ajoutez le code suivant à ce fichier.
body {
font-family: Helvetica, Geneva, Arial, sans-serif;
font-size: small;
font-color: #000;
background-color: #fff;
}
a:link, a:active, a:visited {
color: #CD0000;
}
input {
margin-bottom: 5px;
}
p {
line-height: 150%;
}
div#container {
width: 760px;
margin: 0 auto;
}
div#header {
text-align: center;
padding-bottom: 15px;
}
div#content {
float: left;
width: 450px;
padding: 10px;
}
div#content h3 {
margin-top: 15px;
}
ul#books {
list-style-type: none;
}
ul#books li {
line-height: 140%;
}
div#sidebar {
width: 200px;
margin-left: 480px;
}
ul#subjects {
width: 700px;
text-align: center;
padding: 5px;
background-color: #ececec;
border: 1px solid #ccc;
margin-bottom: 20px;
}
ul#subjects li {
display: inline;
padding-left: 5px;
}Maintenant, actualisez votre navigateur et voyez la différence -
Quelle est la prochaine?
Le chapitre suivant explique comment développer des applications à l'aide de Rails Scaffolding pour donner à l'utilisateur l'accès pour ajouter, supprimer et modifier les enregistrements dans n'importe quelle base de données.
Lorsque vous développez des applications Rails, en particulier celles qui vous fournissent principalement une interface simple vers les données d'une base de données, il peut souvent être utile d'utiliser la méthode d'échafaudage.
L'échafaudage offre plus que des sensations de démonstration bon marché. Voici quelques avantages -
Vous pouvez rapidement obtenir du code devant vos utilisateurs pour obtenir des commentaires.
Vous êtes motivé par un succès plus rapide.
Vous pouvez apprendre comment fonctionne Rails en regardant le code généré.
Vous pouvez utiliser l'échafaudage comme base pour démarrer votre développement.
Exemple d'échafaudage
Pour comprendre l' échafaudage, créons une base de données appeléecookbook et une table appelée recipes.
Création d'une application Web de rails vides
Ouvrez une fenêtre de commande et accédez à l'endroit où vous souhaitez créer ceci cookbookapplication Web. Alors, exécutez la commande suivante pour créer une structure de répertoires complète.
tp> rails new cookbookConfiguration de la base de données
Voici comment créer une base de données -
mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)
mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)Pour indiquer à Rails comment trouver la base de données, modifiez le fichier de configuration cookbook \ config \ database.yml et remplacez le nom de la base de données par cookbook. Laissez le mot de passe vide. Lorsque vous avez terminé, cela devrait ressembler à ceci -
development:
adapter: mysql
database: cookbook
username: root
password: [password]
host: localhost
test:
adapter: mysql
database: cookbook
username: root
password: [password]
host: localhost
production:
adapter: mysql
database: cookbook
username: root
password: [password]
host: localhostRails vous permet d'exécuter en mode développement, en mode test ou en mode production, en utilisant différentes bases de données. Cette application utilise la même base de données pour chacun.
Le code d'échafaudage généré
Avec l'action d'échafaudage, Rails génère tout le code dont il a besoin de manière dynamique. En exécutant scaffold en tant que script, nous pouvons obtenir tout le code écrit sur le disque, où nous pouvons l'examiner, puis commencer à l'adapter à nos besoins.
Alors maintenant, recommençons pour générer manuellement le code Scaffold en utilisant le script d'aide Scaffold -
cookbook> rails generate scaffold recipeIl génère des fichiers automatiques comme indiqué ci-dessous -
Le controlle
Regardons le code derrière le contrôleur. Ce code est généré par lescaffoldGénérateur. Si vous ouvrez app / controllers / recettes_controller.rb, vous trouverez quelque chose comme suit -
class RecipesController < ApplicationController
before_action :set_recipe, only: [:show, :edit, :update, :destroy]
# GET /recipes
# GET /recipes.json
def index
@recipes = Recipe.all
end
# GET /recipes/1
# GET /recipes/1.json
def show
end
# GET /recipes/new
def new
@recipe = Recipe.new
end
# GET /recipes/1/edit
def edit
end
# POST /recipes
# POST /recipes.json
def create
@recipe = Recipe.new(recipe_params)
respond_to do |format|
if @recipe.save
format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
format.json { render :show, status: :created, location: @recipe }
else
format.html { render :new }
format.json { render json: @recipe.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /recipes/1
# PATCH/PUT /recipes/1.json
def update
respond_to do |format|
if @recipe.update(recipe_params)
format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
format.json { render :show, status: :ok, location: @recipe }
else
format.html { render :edit }
format.json { render json: @recipe.errors, status: :unprocessable_entity }
end
end
end
# DELETE /recipes/1
# DELETE /recipes/1.json
def destroy
@recipe.destroy
respond_to do |format|
format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_recipe
@recipe = Recipe.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def recipe_params
params.require(:recipe).permit(:tittle, :instructions)
end
endLorsque l'utilisateur d'une application Rails sélectionne une action, par exemple "Show" - le contrôleur exécutera n'importe quel code dans la section appropriée - "def show" - et ensuite, par défaut, rendra un modèle du même nom - "show.html. erb ". Ce comportement par défaut peut être écrasé.
Le contrôleur utilise des méthodes ActiveRecord telles que find, find_all, new, save, update_attributes et destroy pour déplacer les données vers et depuis les tables de la base de données. Notez que vous n'avez pas à écrire d'instructions SQL, les rails s'en chargeront automatiquement.
Cette seule ligne de code donnera vie à la table de la base de données. Il fournira une interface simple à vos données et des moyens de -
- Créer de nouvelles entrées
- Modifier les entrées actuelles
- Affichage des entrées actuelles
- Détruire les entrées actuelles
Lors de la création ou de la modification d'une entrée, scaffold fera tout le travail acharné comme la génération et la gestion de formulaires pour vous, et fournira même une génération de formulaires intelligente, prenant en charge les types d'entrées suivants -
- Chaînes de texte simples
- Zones de texte (ou grands blocs de texte)
- Sélecteurs de date
- Sélecteurs de date et d'heure
Vous pouvez utiliser les migrations Rails pour créer et gérer des tables.
rake db:migrate RAILS_ENV=developmentMaintenant, allez dans le répertoire du livre de recettes et exécutez le serveur Web à l'aide de la commande suivante -
cookbook> rails serverMaintenant, ouvrez un navigateur et accédez à http://127.0.0.1:3000/recipe/new. Cela vous fournira un écran pour créer de nouvelles entrées dans le tableau des recettes. Une capture d'écran est présentée ci-dessous -
Une fois que vous appuyez sur Create pour créer une nouvelle recette, votre enregistrement est ajouté dans le tableau des recettes et il affiche le résultat suivant -
Vous pouvez voir l'option pour modifier, afficher et détruire les enregistrements. Alors, jouez avec ces options.
Vous pouvez également lister toutes les recettes disponibles dans le tableau des recettes en utilisant l'URL http://127.0.0.1:3000/recipe/list.
Améliorer le modèle
Rails vous permet de gérer gratuitement les erreurs. Pour comprendre cela, ajoutez quelques règles de validation au modèle de recette vide -
Modifiez app / models / recette.rb comme suit, puis testez votre application -
class Recipe < ActiveRecord::Base
validates_length_of :title, :within => 1..20
validates_uniqueness_of :title, :message => "already exists"
endCes entrées donneront une vérification automatique.
validates_length_of - le champ n'est pas vide et pas trop long.
validates_uniqueness_of- les valeurs en double sont piégées. Au lieu du message d'erreur Rails par défaut, nous avons donné ici un message personnalisé.
Autre façon de créer des échafaudages
Créez une application comme indiqué ci-dessus et The Generated Scaffold Code comme indiqué ci-dessous
rails g scaffold Recipe tittle:string instructions:textLe code ci-dessus génère les fichiers automatiques avec la base de données en utilisant avec sqlite3 avec le titre et la colonne d'instructions comme indiqué ci-dessous une image.
nous devons migrer la base de données en utilisant la syntaxe ci-dessous.
$ rake db:migrate RAILS_ENV=developmentEnfin, exécutez l'application en utilisant la ligne de commande suivante -
rails serverIl générera le résultat comme indiqué ci-dessus des images de sortie.
Les vues
Toutes les vues et toutes les méthodes de contrôleur correspondantes sont créées par scaffold command et ils sont disponibles dans le répertoire app / views / recettes.
En quoi l'échafaudage est-il différent?
Si vous avez parcouru les chapitres précédents, vous devez avoir vu que nous avions créé des méthodes pour répertorier, afficher, supprimer et créer des données, etc., mais l'échafaudage fait ce travail automatiquement.
Ajax signifie Asynchrone JavaScript et XML. Ajax n'est pas une technologie unique; c'est une suite de plusieurs technologies. Ajax intègre les éléments suivants -
- XHTML pour le balisage des pages Web
- CSS pour le style
- Affichage dynamique et interaction à l'aide du DOM
- Manipulation et échange de données à l'aide de XML
- Récupération de données à l'aide de XMLHttpRequest
- JavaScript comme colle qui relie tout cela ensemble
Ajax vous permet de récupérer des données pour une page Web sans avoir à actualiser le contenu de la page entière. Dans l'architecture Web de base, l'utilisateur clique sur un lien ou soumet un formulaire. Le formulaire est soumis au serveur, qui renvoie ensuite une réponse. La réponse est alors affichée pour l'utilisateur sur une nouvelle page.
Lorsque vous interagissez avec une page Web optimisée par Ajax, elle charge un moteur Ajax en arrière-plan. Le moteur est écrit en JavaScript et sa responsabilité est à la fois de communiquer avec le serveur Web et d'afficher les résultats à l'utilisateur. Lorsque vous soumettez des données à l'aide d'un formulaire optimisé par Ajax, le serveur renvoie un fragment HTML qui contient la réponse du serveur et affiche uniquement les données nouvelles ou modifiées au lieu d'actualiser la page entière.
Pour un détail complet sur AJAX, vous pouvez consulter notre Tutoriel AJAX
Comment Rails implémente Ajax
Rails a un modèle simple et cohérent pour la façon dont il implémente les opérations Ajax. Une fois que le navigateur a rendu et affiché la page Web initiale, différentes actions de l'utilisateur le font afficher une nouvelle page Web (comme toute application Web traditionnelle) ou déclenchent une opération Ajax -
Some trigger fires - Ce déclencheur peut être l'utilisateur cliquant sur un bouton ou un lien, l'utilisateur apportant des modifications aux données sur un formulaire ou dans un champ, ou simplement un déclencheur périodique (basé sur un minuteur).
The web client calls the server- Une méthode JavaScript, XMLHttpRequest , envoie les données associées au déclencheur à un gestionnaire d'actions sur le serveur. Les données peuvent être l'ID d'une case à cocher, le texte d'un champ de saisie ou un formulaire entier.
The server does processing - Le gestionnaire d'actions côté serveur (action du contrôleur Rails) - fait quelque chose avec les données et renvoie un fragment HTML au client Web.
The client receives the response - Le JavaScript côté client, que Rails crée automatiquement, reçoit le fragment HTML et l'utilise pour mettre à jour une partie spécifiée du code HTML de la page actuelle, souvent le contenu d'une balise <div>.
Ces étapes sont le moyen le plus simple d'utiliser Ajax dans une application Rails, mais avec un peu de travail supplémentaire, vous pouvez demander au serveur de renvoyer tout type de données en réponse à une requête Ajax, et vous pouvez créer un JavaScript personnalisé dans le navigateur pour en faire plus. interactions impliquées.
Exemple AJAX
Cet exemple fonctionne basé sur l'échafaudage, le concept Destroy fonctionne basé sur ajax.
Dans cet exemple, nous allons fournir, lister, afficher et créer des opérations sur la table des poneys. Si vous ne comprenez pas la technologie d'échafaudage, nous vous suggérons de parcourir d'abord les chapitres précédents, puis de continuer avec AJAX on Rails.
Créer une application
Commençons par la création d'une application Cela se fera comme suit -
rails new poniesLa commande ci-dessus crée une application, nous devons maintenant appeler le répertoire de l'application en utilisant la commande with cd. Il entrera dans un répertoire d'application, puis nous devons appeler une commande d'échafaudage. Cela se fera comme suit -
rails generate scaffold Pony name:string profession:stringLa commande ci-dessus génère l'échafaudage avec le nom et la colonne de profession. Nous devons migrer la base de données comme suit la commande
rake db:migrateMaintenant, exécutez l'application Rails comme suit la commande
rails sOuvrez maintenant le navigateur Web et appelez une URL comme http: // localhost: 3000 / ponies / new, la sortie sera la suivante
Créer un Ajax
Ouvrez maintenant app / views / ponies / index.html.erb avec les éditeurs de texte appropriés. Mettez à jour votre ligne de destruction avec: remote => true,: class => 'delete_pony'. Enfin, cela ressemble à ceci.
Créez un fichier, destroy.js.erb, placez-le à côté de vos autres fichiers .erb (sous app / views / ponies). Cela devrait ressembler à ceci -
Entrez maintenant le code comme indiqué ci-dessous dans destroy.js.erb
$('.delete_pony').bind('ajax:success', function() {
$(this).closest('tr').fadeOut();
});Maintenant, ouvrez votre fichier de contrôleur qui est placé dans app / controllers / ponies_controller.rb et ajoutez le code suivant dans la méthode destroy comme indiqué ci-dessous -
# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
@pony = Pony.find(params[:id])
@pony.destroy
respond_to do |format|
format.html { redirect_to ponies_url }
format.json { head :no_content }
format.js { render :layout => false }
end
endÀ la page enfin du contrôleur est comme l'image montrée.
Maintenant, exécutez une application, sortie appelée à partir de http: // localhost: 3000 / ponies / new, elle ressemblera à l'image suivante
Appuyez sur le bouton Créer un poney, cela générera le résultat comme suit
Maintenant, cliquez sur le bouton retour, il affichera toutes les informations créées par le poney comme indiqué sur l'image
Jusqu'à présent, nous travaillons sur l'échafaudage, cliquez maintenant sur le bouton de destruction, cela appellera une fenêtre contextuelle comme le montre l'image ci-dessous, la fenêtre contextuelle fonctionne basée sur Ajax.
Si cliquez sur le bouton ok, cela supprimera l'enregistrement du poney. Ici, j'ai cliqué sur le bouton OK. La sortie finale sera la suivante -
Vous pouvez avoir une exigence dans laquelle vous souhaitez que les visiteurs de votre site téléchargent un fichier sur votre serveur. Les rails permettent de gérer très facilement cette exigence. Nous allons maintenant procéder à un projet Rails simple et petit.
Comme d'habitude, commençons avec une nouvelle application Rails appelée testfile. Créons la structure de base de l'application en utilisant une simple commande rails.
tp> rails new testfileAvant de commencer le développement d'applications, nous devons installer les fichiers gem comme indiqué ci-dessous -
gem install carrierwave
gem install bootstrap-sassOuvrez votre fichier gemme et ajoutez les deux gemmes suivantes en bas, comme indiqué dans l'image suivante -
Après avoir ajouté des gemmes dans le fichier gem, nous devons exécuter la commande suivante sur la console -
bundle installCréation du modèle
Nous devons créer un modèle avec deux chaînes comme nom et pièce jointe comme indiqué ci-dessous -
rails g model Resume name:string attachment:stringNous devons créer la migration de la base de données comme indiqué ci-dessous -
rake db:migrateNous devons générer le contrôleur comme indiqué ci-dessous -
rails g controller Resumes index new create destroyGénial! Nous avons maintenant mis en place la structure de base. Nous devons maintenant créer un téléchargeur. Un Uploader est venu du gem carrierwave et il indique à carrierwave comment gérer les fichiers. En bref, il contenait toutes les fonctionnalités de traitement de fichiers. Exécutez la commande pour créer un téléchargeur comme indiqué ci-dessous
rails g uploader attachmentOuvrez maintenant le modèle de CV et appelez le téléchargeur comme indiqué ci-dessous. Le modèle de CV a été placé dans app / models / resume.rb -
class Resume < ActiveRecord::Base
mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
validates :name, presence: true # Make sure the owner's name is present.
endAvant de travailler sur le contrôleur, nous devons modifier notre config / routes.db comme indiqué ci-dessous -
CarrierWaveExample::Application.routes.draw do
resources :resumes, only: [:index, :new, :create, :destroy]
root "resumes#index"
endPermet de modifier le contrôleur comme indiqué ci-dessous.
class ResumesController < ApplicationController
def index
@resumes = Resume.all
end
def new
@resume = Resume.new
end
def create
@resume = Resume.new(resume_params)
if @resume.save
redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
else
render "new"
end
end
def destroy
@resume = Resume.find(params[:id])
@resume.destroy
redirect_to resumes_path, notice: "The resume #{@resume.name} has been deleted."
end
private
def resume_params
params.require(:resume).permit(:name, :attachment)
end
endAjoutons l'implémentation de bootstrap dans le fichier css file.css pourrait être dans app / assets / stylesheets / resumes.css.scss
@import "bootstrap";Ouvrez maintenant app / views / layouts / application.html.erb et ajoutez des codes comme indiqué ci-dessous -
<!DOCTYPE html>
<html>
<head>
<title>Tutorialspoint</title>
<%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
<%= javascript_include_tag "application", "data-turbolinks-track" => true %>
<%= csrf_meta_tags %>
</head>
<body>
<div class = "container" style = "padding-top:20px;">
<%= yield %>
</div>
</body>
</html>Nous devons maintenant configurer les vues d'index comme indiqué ci-dessous -
<% if !flash[:notice].blank? %>
<div class = "alert alert-info">
<%= flash[:notice] %>
</div>
<% end %>
<br />
<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />
<table class = "table table-bordered table-striped">
<thead>.
<tr>
<th>Name</th>
<th>Download Link</th>
<th> </th>
</tr>
</thead>
<tbody>
<% @resumes.each do |resume| %>
<tr>
<td><%= resume.name %></td>
<td><%= link_to "Download Resume", resume.attachment_url %></td>
<td><%= button_to "Delete", resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
</tr>
<% end %>
</tbody>
</table>Maintenant, éditons new.html.erb et ajoutons notre code de formulaire.
<% if [email protected]? %>
<div class = "alert alert-error">
<ul>
<% @resume.errors.full_messages.each do |msg| %>
<li><%= msg %></li>
<% end %>
</ul>
</div>
<% end %>
<div class = "well">
<%= form_for @resume, html: { multipart: true } do |f| %>
<%= f.label :name %>
<%= f.text_field :name %>
<%= f.label :attachment %>
<%= f.file_field :attachment %>
<%= f.submit "Save", class: "btn btn-primary" %>
<% end %>
</div>Démarrez maintenant le serveur et visitez http: // localhost: 3000. Il produira un écran similaire à ce qui suit -
Une dernière chose que nous devons faire est de filtrer la liste des types de fichiers autorisés. Pour cela, nous devons ajouter un code simple comme indiqué ci-dessous à app / uploaders / attachment_uploader.rb
class AttachmentUploader < CarrierWave::Uploader::Base
storage :file
def store_dir
"uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
end
def extension_white_list
%w(pdf doc htm html docx)
end
endDémarrez maintenant le serveur et visitez http: // localhost: 3000. Saisissez maintenant un format incorrect; cela générera un mauvais message comme indiqué ci-dessous -
Pour un détail complet sur File objet, vous devez passer par le Ruby Reference Manual.
Action Mailerest le composant Rails qui permet aux applications d'envoyer et de recevoir des e-mails. Dans ce chapitre, nous verrons comment envoyer un e-mail à l'aide de Rails. Commençons par créer unemails projet à l'aide de la commande suivante.
tp> rails new mailtestCela créera le cadre requis pour continuer. Maintenant, nous allons commencer par configurer l'ActionMailer.
Mailer d'action - Configuration
Voici les étapes à suivre pour terminer votre configuration avant de procéder au travail proprement dit -
Accédez au dossier de configuration de votre projet de courrier électronique et ouvrez le fichier environment.rb et ajoutez la ligne suivante au bas de ce fichier.
config.action_mailer.delivery_method = :smtpIl indique à ActionMailer que vous souhaitez utiliser le serveur SMTP. Vous pouvez également le définir sur: sendmail si vous utilisez un système d'exploitation basé sur Unix tel que Mac OS X ou Linux.
Ajoutez également les lignes de code suivantes au bas de votre environnement.rb.
config.action_mailer.smtp_settings = {
address: 'smtp.gmail.com',
port: 587,
domain: 'example.com',
user_name: '<username>',
password: '<password>',
authentication: 'plain',
enable_starttls_auto: true
}Remplacez chaque valeur de hachage par les paramètres appropriés pour votre serveur SMTP (Simple Mail Transfer Protocol). Vous pouvez récupérer ces informations auprès de votre fournisseur d'accès Internet si vous ne le savez pas déjà. Vous n'avez pas besoin de modifier le numéro de port 25 et le type d'authentification si vous utilisez un serveur SMTP standard.
Vous pouvez également modifier le format de message électronique par défaut. Si vous préférez envoyer des e-mails au format HTML plutôt qu'au format texte brut, ajoutez également la ligne suivante à config / environment.rb -
ActionMailer::Base.default_content_type = "text/html"ActionMailer :: Base.default_content_type peut être défini sur "text / plain", "text / html" et "text / enriched". La valeur par défaut est "text / plain".
La prochaine étape sera de créer un mailer
Générer un mailer
Utilisez la commande suivante pour générer un mailer comme suit -
tp> cd emails
emails> rails generate mailer UsermailerCela créera un fichier user_mailer.rb dans le répertoire app \ mailer. Vérifiez le contenu de ce fichier comme suit -
class Emailer < ActionMailer::Base
endCréons une méthode comme suit -
class UserMailer < ApplicationMailer
default from: '[email protected]'
def welcome_email(user)
@user = user
@url = 'http://www.gmail.com'
mail(to: @user.email, subject: 'Welcome to My Awesome Site')
end
enddefault Hash- Il s'agit d'un hachage des valeurs par défaut pour tout e-mail que vous envoyez à partir de ce mailer. Dans ce cas, nous définissons l'en-tête: from sur une valeur pour tous les messages de cette classe. Cela peut être remplacé par e-mail
mail - Le message électronique réel, nous transmettons les en-têtes: to et: subject dans.
Créez un fichier appelé welcome_email.html.erb dans app / views / user_mailer /. Ce sera le modèle utilisé pour l'e-mail, formaté en HTML -
<html>
<head>
<meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
</head>
<body>
<h1>Welcome to example.com, <%= @user.name %></h1>
<p>
You have successfully signed up to example.com,your username is:
<%= @user.login %>.<br>
</p>
<p>
To login to the site, just follow this link:
<%= @url %>.
</p>
<p>Thanks for joining and have a great day!</p>
</body>
</html>Ensuite, nous allons créer une partie de texte pour cette application comme suit -
Welcome to example.com, <%= @user.name %>
===============================================
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
To login to the site, just follow this link: <%= @url %>.
Thanks for joining and have a great day!Appeler l'expéditeur
Tout d'abord, créons un échafaudage utilisateur simple
$ bin/rails generate scaffold user name email login
$ bin/rake db:migrateAction Mailer est bien intégré à Active Job afin que vous puissiez envoyer des e-mails en dehors du cycle de demande-réponse, afin que l'utilisateur n'ait pas à attendre dessus -
class UsersController < ApplicationController
# POST /users
# POST /users.json
def create
@user = User.new(params[:user])
respond_to do |format|
if @user.save
# Tell the UserMailer to send a welcome email after save
UserMailer.welcome_email(@user).deliver_later
format.html { redirect_to(@user, notice: 'User was successfully created.') }
format.json { render json: @user, status: :created, location: @user }
else
format.html { render action: 'new' }
format.json { render json: @user.errors, status: :unprocessable_entity }
end
end
end
endMaintenant, testez votre application en utilisant http://127.0.0.1:3000/users/new. Il affiche l'écran suivant et en utilisant cet écran, vous pourrez envoyer votre message à n'importe qui.
Cela enverra votre message et affichera le message texte "Message envoyé avec succès" et sortira comme suit -
sent mail to [email protected] (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: [email protected]
To: [email protected]
Message-Id: <[email protected]>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bitPour plus d'informations sur l'envoi d'e-mails à l'aide de Rails, veuillez consulter ActionMailer .