NOTE : Ce tutoriel suppose que vous avez des connaissances de base en Rails en lisant le Guide de démarrage avec Rails.
1 Créer une application Rails
Tout d'abord, créons une application Rails simple en utilisant la commande rails new
.
Nous utiliserons cette application pour jouer et découvrir toutes les commandes décrites dans ce guide.
INFO : Vous pouvez installer le gem Rails en tapant gem install rails
, si vous ne l'avez pas déjà.
1.1 rails new
Le premier argument que nous passerons à la commande rails new
est le nom de l'application.
$ rails new my_app
create
create README.md
create Rakefile
create config.ru
create .gitignore
create Gemfile
create app
...
create tmp/cache
...
run bundle install
Rails met en place ce qui semble être une énorme quantité de choses pour une si petite commande ! Nous avons maintenant toute la structure de répertoire Rails avec tout le code dont nous avons besoin pour exécuter notre application simple dès le départ.
Si vous souhaitez ignorer certains fichiers générés ou ignorer certaines bibliothèques, vous pouvez ajouter l'un des arguments suivants à votre commande rails new
:
Argument | Description |
---|---|
--skip-git |
Ignorer git init, .gitignore et .gitattributes |
--skip-docker |
Ignorer Dockerfile, .dockerignore et bin/docker-entrypoint |
--skip-keeps |
Ignorer les fichiers .keep de contrôle de source |
--skip-action-mailer |
Ignorer les fichiers Action Mailer |
--skip-action-mailbox |
Ignorer la gem Action Mailbox |
--skip-action-text |
Ignorer la gem Action Text |
--skip-active-record |
Ignorer les fichiers Active Record |
--skip-active-job |
Ignorer Active Job |
--skip-active-storage |
Ignorer les fichiers Active Storage |
--skip-action-cable |
Ignorer les fichiers Action Cable |
--skip-asset-pipeline |
Ignorer l'Asset Pipeline |
--skip-javascript |
Ignorer les fichiers JavaScript |
--skip-hotwire |
Ignorer l'intégration Hotwire |
--skip-jbuilder |
Ignorer la gem jbuilder |
--skip-test |
Ignorer les fichiers de test |
--skip-system-test |
Ignorer les fichiers de test système |
--skip-bootsnap |
Ignorer la gem bootsnap |
Ce ne sont que quelques-unes des options acceptées par rails new
. Pour une liste complète des options, tapez rails new --help
.
1.2 Préconfigurer une base de données différente
Lors de la création d'une nouvelle application Rails, vous avez la possibilité de spécifier le type de base de données que votre application va utiliser. Cela vous fera gagner quelques minutes et certainement beaucoup de frappes.
Voyons ce que l'option --database=postgresql
fera pour nous :
$ rails new petstore --database=postgresql
create
create app/controllers
create app/helpers
...
Voyons ce qu'il a mis dans notre config/database.yml
:
# PostgreSQL. Versions 9.3 and up are supported.
#
# Install the pg driver:
# gem install pg
# On macOS with Homebrew:
# gem install pg -- --with-pg-config=/usr/local/bin/pg_config
# On Windows:
# gem install pg
# Choose the win32 build.
# Install PostgreSQL and put its /bin directory on your path.
#
# Configure Using Gemfile
# gem "pg"
#
default: &default
adapter: postgresql
encoding: unicode
# For details on connection pooling, see Rails configuration guide
# https://guides.rubyonrails.org/configuring.html#database-pooling
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
development:
<<: *default
database: petstore_development
...
Il a généré une configuration de base de données correspondant à notre choix de PostgreSQL.
2 Principes de base de la ligne de commande
Il existe quelques commandes absolument essentielles pour une utilisation quotidienne de Rails. Dans l'ordre d'utilisation probable, ce sont :
bin/rails console
bin/rails server
bin/rails test
bin/rails generate
bin/rails db:migrate
bin/rails db:create
bin/rails routes
bin/rails dbconsole
rails new app_name
Vous pouvez obtenir une liste des commandes Rails disponibles, qui dépendront souvent de votre répertoire actuel, en tapant rails --help
. Chaque commande a une description et devrait vous aider à trouver ce dont vous avez besoin.
$ rails --help
Usage:
bin/rails COMMAND [options]
You must specify a command. The most common commands are:
generate Generate new code (short-cut alias: "g")
console Start the Rails console (short-cut alias: "c")
server Start the Rails server (short-cut alias: "s")
...
All commands can be run with -h (or --help) for more information.
In addition to those commands, there are:
about List versions of all Rails ...
assets:clean[keep] Remove old compiled assets
assets:clobber Remove compiled assets
assets:environment Load asset compile environment
assets:precompile Compile all the assets ...
...
db:fixtures:load Load fixtures into the ...
db:migrate Migrate the database ...
db:migrate:status Display status of migrations
db:rollback Roll the schema back to ...
db:schema:cache:clear Clears a db/schema_cache.yml file
db:schema:cache:dump Create a db/schema_cache.yml file
db:schema:dump Create a database schema file (either db/schema.rb or db/structure.sql ...
db:schema:load Load a database schema file (either db/schema.rb or db/structure.sql ...
db:seed Load the seed data ...
db:version Retrieve the current schema ...
...
restart Restart app by touching ...
tmp:create Create tmp directories ...
2.1 bin/rails server
La commande bin/rails server
lance un serveur web nommé Puma qui est inclus avec Rails. Vous l'utiliserez chaque fois que vous voudrez accéder à votre application via un navigateur web.
Sans autre travail, bin/rails server
exécutera notre nouvelle application Rails :
$ cd my_app
$ bin/rails server
=> Démarrage de Puma
=> Démarrage de l'application Rails 7.0.0 en mode développement
=> Exécutez `bin/rails server --help` pour plus d'options de démarrage
Puma démarre en mode unique...
* Version 3.12.1 (ruby 2.5.7-p206), nom de code : Llamas in Pajamas
* Threads minimaux : 5, threads maximaux : 5
* Environnement : développement
* Écoute sur tcp://localhost:3000
Utilisez Ctrl-C pour arrêter
Avec seulement trois commandes, nous avons créé un serveur Rails écoutant sur le port 3000. Allez dans votre navigateur et ouvrez http://localhost:3000, vous verrez une application Rails de base en cours d'exécution.
INFO : Vous pouvez également utiliser l'alias "s" pour démarrer le serveur : bin/rails s
.
Le serveur peut être exécuté sur un port différent en utilisant l'option -p
. L'environnement de développement par défaut peut être modifié en utilisant l'option -e
.
$ bin/rails server -e production -p 4000
L'option -b
lie Rails à l'adresse IP spécifiée, par défaut c'est localhost. Vous pouvez exécuter un serveur en tant que démon en passant l'option -d
.
2.2 bin/rails generate
La commande bin/rails generate
utilise des modèles pour créer de nombreuses choses. En exécutant bin/rails generate
seul, vous obtenez une liste des générateurs disponibles :
INFO : Vous pouvez également utiliser l'alias "g" pour invoquer la commande de génération : bin/rails g
.
$ bin/rails generate
Utilisation :
bin/rails generate GENERATOR [args] [options]
...
...
Veuillez choisir un générateur ci-dessous.
Rails :
assets
channel
controller
generator
...
...
NOTE : Vous pouvez installer d'autres générateurs via des gemmes de générateur, des parties de plugins que vous installerez sans aucun doute, et vous pouvez même créer les vôtres !
L'utilisation de générateurs vous fera gagner beaucoup de temps en écrivant du code de base, du code nécessaire au bon fonctionnement de l'application.
Créons notre propre contrôleur avec le générateur de contrôleurs. Mais quelle commande devons-nous utiliser ? Demandons au générateur :
INFO : Toutes les utilitaires de la console Rails ont un texte d'aide. Comme la plupart des utilitaires *nix, vous pouvez essayer d'ajouter --help
ou -h
à la fin, par exemple bin/rails server --help
.
$ bin/rails generate controller
Utilisation :
bin/rails generate controller NAME [action action] [options]
...
...
Description :
...
Pour créer un contrôleur dans un module, spécifiez le nom du contrôleur comme un chemin tel que 'parent_module/nom_du_contrôleur'.
...
Exemple :
`bin/rails generate controller CreditCards open debit credit close`
Contrôleur de carte de crédit avec des URL comme /credit_cards/debit.
Contrôleur : app/controllers/credit_cards_controller.rb
Test : test/controllers/credit_cards_controller_test.rb
Vues : app/views/credit_cards/debit.html.erb [...]
Aide : app/helpers/credit_cards_helper.rb
Le générateur de contrôleurs attend des paramètres sous la forme generate controller NomDuContrôleur action1 action2
. Créons un contrôleur Greetings
avec une action hello, qui nous dira quelque chose de gentil.
$ bin/rails generate controller Greetings hello
create app/controllers/greetings_controller.rb
route get 'greetings/hello'
invoke erb
create app/views/greetings
create app/views/greetings/hello.html.erb
invoke test_unit
create test/controllers/greetings_controller_test.rb
invoke helper
create app/helpers/greetings_helper.rb
invoke test_unit
Qu'a généré tout cela ? Cela a veillé à ce qu'un tas de répertoires soient présents dans notre application, et a créé un fichier de contrôleur, un fichier de vue, un fichier de test fonctionnel, un assistant pour la vue, un fichier JavaScript et un fichier de feuille de style.
Consultez le contrôleur et modifiez-le un peu (dans app/controllers/greetings_controller.rb
) :
class GreetingsController < ApplicationController
def hello
@message = "Bonjour, comment ça va aujourd'hui ?"
end
end
Ensuite, la vue, pour afficher notre message (dans app/views/greetings/hello.html.erb
) :
<h1>Un salut pour vous !</h1>
<p><%= @message %></p>
Lancez votre serveur en utilisant bin/rails server
.
$ bin/rails server
=> Démarrage de Puma...
L'URL sera http://localhost:3000/greetings/hello.
INFO : Avec une application Rails normale, vos URL suivront généralement le modèle http://(hôte)/(contrôleur)/(action), et une URL comme http://(hôte)/(contrôleur) exécutera l'action index de ce contrôleur.
Rails est livré avec un générateur pour les modèles de données également.
$ bin/rails generate model
Utilisation :
bin/rails generate model NAME [field[:type][:index] field[:type][:index]] [options]
...
Options ActiveRecord :
[--migration], [--no-migration] # Indique quand générer une migration
# Par défaut : true
...
Description :
Génère un nouveau modèle. Passez le nom du modèle, en CamelCase ou en underscore, et une liste facultative de paires d'attributs en tant qu'arguments.
...
NOTE : Pour obtenir une liste des types de champ disponibles pour le paramètre type
, consultez la documentation de l'API pour la méthode add_column
du module SchemaStatements
. Le paramètre index
génère un index correspondant pour la colonne.
Mais au lieu de générer directement un modèle (ce que nous ferons plus tard), configurons une échafaudage. Un échafaudage dans Rails est un ensemble complet de modèle, de migration de base de données pour ce modèle, de contrôleur pour le manipuler, de vues pour afficher et manipuler les données, et d'un ensemble de tests pour chacun des éléments précédents.
Nous allons configurer une ressource simple appelée "HighScore" qui suivra notre meilleur score sur les jeux vidéo auxquels nous jouons.
$ bin/rails generate scaffold HighScore game:string score:integer
invoke active_record
create db/migrate/20190416145729_create_high_scores.rb
create app/models/high_score.rb
invoke test_unit
create test/models/high_score_test.rb
create test/fixtures/high_scores.yml
invoke resource_route
route resources :high_scores
invoke scaffold_controller
create app/controllers/high_scores_controller.rb
invoke erb
create app/views/high_scores
create app/views/high_scores/index.html.erb
create app/views/high_scores/edit.html.erb
create app/views/high_scores/show.html.erb
create app/views/high_scores/new.html.erb
create app/views/high_scores/_form.html.erb
invoke test_unit
create test/controllers/high_scores_controller_test.rb
create test/system/high_scores_test.rb
invoke helper
create app/helpers/high_scores_helper.rb
invoke test_unit
invoke jbuilder
create app/views/high_scores/index.json.jbuilder
create app/views/high_scores/show.json.jbuilder
create app/views/high_scores/_high_score.json.jbuilder
Le générateur crée le modèle, les vues, le contrôleur, la route resource et la migration de base de données (qui crée la table high_scores
) pour HighScore. Et il ajoute des tests pour ceux-ci.
La migration nécessite que nous migrions, c'est-à-dire que nous exécutions du code Ruby (le fichier 20190416145729_create_high_scores.rb
à partir de la sortie ci-dessus) pour modifier le schéma de notre base de données. Quelle base de données ? La base de données SQLite3 que Rails créera pour nous lorsque nous exécuterons la commande bin/rails db:migrate
. Nous en parlerons plus en détail ci-dessous.
$ bin/rails db:migrate
== CreateHighScores: migrating ===============================================
-- create_table(:high_scores)
-> 0.0017s
== CreateHighScores: migrated (0.0019s) ======================================
Parlons des tests unitaires. Les tests unitaires sont du code qui teste et fait des assertions sur du code. En test unitaire, nous prenons une petite partie de code, disons une méthode d'un modèle, et testons ses entrées et sorties. Les tests unitaires sont vos amis. Plus tôt vous acceptez le fait que votre qualité de vie augmentera considérablement lorsque vous testerez unitairement votre code, mieux ce sera. Sérieusement. Veuillez consulter le guide de test pour un aperçu détaillé des tests unitaires.
Voyons l'interface que Rails a créée pour nous.
$ bin/rails server
Allez dans votre navigateur et ouvrez http://localhost:3000/high_scores, maintenant nous pouvons créer de nouveaux meilleurs scores (55,160 sur Space Invaders !)
2.3 bin/rails console
La commande console
vous permet d'interagir avec votre application Rails depuis la ligne de commande. En dessous, bin/rails console
utilise IRB, donc si vous l'avez déjà utilisé, vous serez à l'aise. Cela est utile pour tester rapidement des idées avec du code et modifier les données côté serveur sans toucher au site web.
Vous pouvez également utiliser l'alias "c" pour invoquer la console : bin/rails c
.
Vous pouvez spécifier l'environnement dans lequel la commande console
doit fonctionner.
$ bin/rails console -e staging
Si vous souhaitez tester du code sans modifier de données, vous pouvez le faire en invoquant bin/rails console --sandbox
.
$ bin/rails console --sandbox
Loading development environment in sandbox (Rails 7.1.0)
Any modifications you make will be rolled back on exit
irb(main):001:0>
2.3.1 Les objets app
et helper
Dans la bin/rails console
, vous avez accès aux instances app
et helper
.
Avec la méthode app
, vous pouvez accéder aux assistants de routage nommés, ainsi qu'effectuer des requêtes.
irb> app.root_path
=> "/"
irb> app.get _
Started GET "/" for 127.0.0.1 at 2014-06-19 10:41:57 -0300
...
Avec la méthode helper
, il est possible d'accéder aux assistants de Rails et de votre application.
irb> helper.time_ago_in_words 30.days.ago
=> "about 1 month"
irb> helper.my_custom_helper
=> "my custom helper"
2.4 bin/rails dbconsole
bin/rails dbconsole
détermine quelle base de données vous utilisez et vous place dans l'interface en ligne de commande que vous utiliseriez avec celle-ci (et détermine également les paramètres de ligne de commande à lui donner !). Il prend en charge MySQL (y compris MariaDB), PostgreSQL et SQLite3.
Vous pouvez également utiliser l'alias "db" pour invoquer la dbconsole : bin/rails db
.
Si vous utilisez plusieurs bases de données, bin/rails dbconsole
se connectera à la base de données principale par défaut. Vous pouvez spécifier à quelle base de données vous connecter en utilisant --database
ou --db
:
$ bin/rails dbconsole --database=animals
2.5 bin/rails runner
runner
exécute du code Ruby dans le contexte de Rails de manière non interactive. Par exemple :
$ bin/rails runner "Model.long_running_method"
Vous pouvez également utiliser l'alias "r" pour invoquer le runner : bin/rails r
.
Vous pouvez spécifier l'environnement dans lequel la commande runner
doit fonctionner en utilisant l'option -e
.
$ bin/rails runner -e staging "Model.long_running_method"
Vous pouvez même exécuter du code Ruby écrit dans un fichier avec le runner.
$ bin/rails runner lib/code_to_be_run.rb
2.6 bin/rails destroy
Pensez à destroy
comme l'opposé de generate
. Il va comprendre ce que generate
a fait et l'annuler.
Vous pouvez également utiliser l'alias "d" pour invoquer la commande destroy : bin/rails d
.
$ bin/rails generate model Oops
invoke active_record
create db/migrate/20120528062523_create_oops.rb
create app/models/oops.rb
invoke test_unit
create test/models/oops_test.rb
create test/fixtures/oops.yml
$ bin/rails destroy model Oops
invoke active_record
remove db/migrate/20120528062523_create_oops.rb
remove app/models/oops.rb
invoke test_unit
remove test/models/oops_test.rb
remove test/fixtures/oops.yml
2.7 bin/rails about
bin/rails about
donne des informations sur les numéros de version de Ruby, RubyGems, Rails, les sous-composants de Rails, le dossier de votre application, le nom de l'environnement Rails actuel, l'adaptateur de base de données de votre application et la version du schéma. C'est utile lorsque vous avez besoin de demander de l'aide, de vérifier si un correctif de sécurité peut vous affecter ou lorsque vous avez besoin de statistiques pour une installation Rails existante.
$ bin/rails about
About your application's environment
Rails version 7.0.0
Ruby version 2.7.0 (x86_64-linux)
RubyGems version 2.7.3
Rack version 2.0.4
JavaScript Runtime Node.js (V8)
Middleware: Rack::Sendfile, ActionDispatch::Static, ActionDispatch::Executor, ActiveSupport::Cache::Strategy::LocalCache::Middleware, Rack::Runtime, Rack::MethodOverride, ActionDispatch::RequestId, ActionDispatch::RemoteIp, Sprockets::Rails::QuietAssets, Rails::Rack::Logger, ActionDispatch::ShowExceptions, WebConsole::Middleware, ActionDispatch::DebugExceptions, ActionDispatch::Reloader, ActionDispatch::Callbacks, ActiveRecord::Migration::CheckPending, ActionDispatch::Cookies, ActionDispatch::Session::CookieStore, ActionDispatch::Flash, Rack::Head, Rack::ConditionalGet, Rack::ETag
Application root /home/foobar/my_app
Environment development
Database adapter sqlite3
Database schema version 20180205173523
2.8 bin/rails assets:
Vous pouvez précompiler les assets dans app/assets
en utilisant bin/rails assets:precompile
et supprimer les anciens assets compilés en utilisant bin/rails assets:clean
. La commande assets:clean
permet des déploiements progressifs qui peuvent encore être liés à un ancien asset pendant que les nouveaux assets sont en cours de construction.
Si vous souhaitez effacer complètement public/assets
, vous pouvez utiliser bin/rails assets:clobber
.
2.9 bin/rails db:
Les commandes les plus courantes de l'espace de noms db:
de Rails sont migrate
et create
, et il est intéressant d'essayer toutes les commandes de migration Rails (up
, down
, redo
, reset
). bin/rails db:version
est utile lors du dépannage, il vous indique la version actuelle de la base de données.
Plus d'informations sur les migrations peuvent être trouvées dans le guide Migrations.
2.10 bin/rails notes
bin/rails notes
recherche dans votre code les commentaires commençant par un mot-clé spécifique. Vous pouvez vous référer à bin/rails notes --help
pour obtenir des informations sur l'utilisation.
Par défaut, il recherchera dans les répertoires app
, config
, db
, lib
et test
les annotations FIXME, OPTIMIZE et TODO dans les fichiers avec les extensions .builder
, .rb
, .rake
, .yml
, .yaml
, .ruby
, .css
, .js
et .erb
.
$ bin/rails notes
app/controllers/admin/users_controller.rb:
* [ 20] [TODO] any other way to do this?
* [132] [FIXME] high priority for next deploy
lib/school.rb:
* [ 13] [OPTIMIZE] refactor this code to make it faster
* [ 17] [FIXME]
2.10.1 Annotations
Vous pouvez passer des annotations spécifiques en utilisant l'argument --annotations
. Par défaut, il recherchera les annotations FIXME, OPTIMIZE et TODO.
Notez que les annotations sont sensibles à la casse.
$ bin/rails notes --annotations FIXME RELEASE
app/controllers/admin/users_controller.rb:
* [101] [RELEASE] We need to look at this before next release
* [132] [FIXME] high priority for next deploy
lib/school.rb:
* [ 17] [FIXME]
2.10.2 Tags
Vous pouvez ajouter plus de tags par défaut à rechercher en utilisant config.annotations.register_tags
. Il reçoit une liste de tags.
config.annotations.register_tags("DEPRECATEME", "TESTME")
$ bin/rails notes
app/controllers/admin/users_controller.rb:
* [ 20] [TODO] do A/B testing on this
* [ 42] [TESTME] this needs more functional tests
* [132] [DEPRECATEME] ensure this method is deprecated in next release
2.10.3 Répertoires
Vous pouvez ajouter plus de répertoires par défaut à rechercher en utilisant config.annotations.register_directories
. Il reçoit une liste de noms de répertoires.
config.annotations.register_directories("spec", "vendor")
$ bin/rails notes
app/controllers/admin/users_controller.rb:
* [ 20] [TODO] any other way to do this?
* [132] [FIXME] high priority for next deploy
lib/school.rb:
* [ 13] [OPTIMIZE] Refactor this code to make it faster
* [ 17] [FIXME]
spec/models/user_spec.rb:
* [122] [TODO] Verify the user that has a subscription works
vendor/tools.rb:
* [ 56] [TODO] Get rid of this dependency
2.10.4 Extensions
Vous pouvez ajouter plus d'extensions de fichiers par défaut à rechercher en utilisant config.annotations.register_extensions
. Il reçoit une liste d'extensions avec sa regex correspondante pour les associer.
config.annotations.register_extensions("scss", "sass") { |annotation| /\/\/\s*(#{annotation}):?\s*(.*)$/ }
$ bin/rails notes
app/controllers/admin/users_controller.rb:
* [ 20] [TODO] any other way to do this?
* [132] [FIXME] high priority for next deploy
app/assets/stylesheets/application.css.sass:
* [ 34] [TODO] Use pseudo element for this class
app/assets/stylesheets/application.css.scss:
* [ 1] [TODO] Split into multiple components
lib/school.rb:
* [ 13] [OPTIMIZE] Refactor this code to make it faster
* [ 17] [FIXME]
spec/models/user_spec.rb:
* [122] [TODO] Verify the user that has a subscription works
vendor/tools.rb:
* [ 56] [TODO] Get rid of this dependency
2.11 bin/rails routes
bin/rails routes
affiche toutes les routes définies, ce qui est utile pour résoudre les problèmes de routage dans votre application ou pour avoir une bonne vue d'ensemble des URL dans une application que vous essayez de comprendre.
2.12 bin/rails test
Une bonne description des tests unitaires dans Rails est donnée dans Un guide pour tester les applications Rails
Rails est livré avec un framework de test appelé minitest. Rails doit sa stabilité à l'utilisation de tests. Les commandes disponibles dans l'espace de noms test:
aident à exécuter les différents tests que vous écrirez, espérons-le.
2.13 bin/rails tmp:
Le répertoire Rails.root/tmp
est, comme le répertoire /tmp de *nix, l'endroit où sont stockés les fichiers temporaires tels que les fichiers d'identifiant de processus et les actions mises en cache.
Les commandes avec l'espace de noms tmp:
vous aideront à effacer et à créer le répertoire Rails.root/tmp
:
bin/rails tmp:cache:clear
effacetmp/cache
.bin/rails tmp:sockets:clear
effacetmp/sockets
.bin/rails tmp:screenshots:clear
effacetmp/screenshots
.bin/rails tmp:clear
efface tous les fichiers de cache, de sockets et de captures d'écran.bin/rails tmp:create
crée les répertoires tmp pour le cache, les sockets et les pids.
2.14 Divers
bin/rails initializers
affiche tous les initializers définis dans l'ordre où ils sont invoqués par Rails.bin/rails middleware
liste la pile de middleware Rack activée pour votre application.bin/rails stats
est idéal pour consulter les statistiques sur votre code, affichant des choses comme les KLOCs (milliers de lignes de code) et le ratio de code à tester.bin/rails secret
vous donnera une clé pseudo-aléatoire à utiliser pour votre secret de session.bin/rails time:zones:all
liste tous les fuseaux horaires connus de Rails.
2.15 Tâches Rake personnalisées
Les tâches Rake personnalisées ont une extension .rake
et sont placées dans Rails.root/lib/tasks
. Vous pouvez créer ces tâches Rake personnalisées avec la commande bin/rails generate task
.
desc "Je suis une description courte mais complète pour ma super tâche"
task task_name: [:prerequisite_task, :another_task_we_depend_on] do
# Tout votre code magique ici
# Tout code Ruby valide est autorisé
end
Pour passer des arguments à votre tâche Rake personnalisée :
task :task_name, [:arg_1] => [:prerequisite_1, :prerequisite_2] do |task, args|
argument_1 = args.arg_1
end
Vous pouvez regrouper les tâches en les plaçant dans des espaces de noms :
namespace :db do
desc "Cette tâche ne fait rien"
task :nothing do
# Sérieusement, rien
end
end
L'invocation des tâches ressemblera à ceci :
$ bin/rails task_name
$ bin/rails "task_name[value 1]" # l'ensemble de la chaîne d'arguments doit être entre guillemets
$ bin/rails "task_name[value 1,value2,value3]" # séparez les arguments multiples par une virgule
$ bin/rails db:nothing
Si vous avez besoin d'interagir avec les modèles de votre application, d'effectuer des requêtes sur la base de données, etc., votre tâche doit dépendre de la tâche environment
, qui chargera le code de votre application.
task task_that_requires_app_code: [:environment] do
User.create!
end
Retour d'information
Vous êtes encouragé à contribuer à l'amélioration de la qualité de ce guide.
Veuillez contribuer si vous trouvez des fautes de frappe ou des erreurs factuelles. Pour commencer, vous pouvez lire notre contribution à la documentation section.
Vous pouvez également trouver du contenu incomplet ou des informations qui ne sont pas à jour. Veuillez ajouter toute documentation manquante pour la version principale. Assurez-vous de vérifier Edge Guides d'abord pour vérifier si les problèmes ont déjà été résolus ou non sur la branche principale. Consultez les Directives des guides Ruby on Rails pour le style et les conventions.
Si pour une raison quelconque vous repérez quelque chose à corriger mais ne pouvez pas le faire vous-même, veuillez ouvrir un problème.
Et enfin, toute discussion concernant la documentation de Ruby on Rails est la bienvenue sur le Forum officiel de Ruby on Rails.