Étapes de création d'une application Rails 3.1

creation_app_rails_31

# Rails 3.1 doit être installé sur la machine

#--------------------------------------------------------------------------
# OUTILS UTILISÉS
#
#
# Outils utilisés :
#   - TextMate comme éditeur de texte
#   - Terminal comme console (mais TextMate peut être utilisé aussi)
#   - Firefox  comme navigateur de développement
#   - Firebug  comme outil de débuggage
#   - Git      pour le versionnage
#   - Github   comme hébergement de versionnage
#
# L'application est créée avec les modules de test Rspec, Cucumber, Factory
# et Haml
#
#--------------------------------------------------------------------------
# NOMENCLATURE
#
#   o          Une opération (qui peut être complexe)
#   $          Une commande à passer en ligne de commande (Terminal)
#   >          Destination de l'opération (p.e. un fichier)
#   |*...*|    Une variable
#   [?...?]    Texte optionnel
#
#   =>         Résultat d'une opération
#
#
#--------------------------------------------------------------------------
# SYNOPSIS DE CRÉATION

o Se placer dans le dossier où créer l'application
  $ cd |*path/to/apps/*|

o Créer l'application Rails
  $ rails new |*NouvelleApp*| -T --with-dispatchers
  => rails crée la nouvelle application (-T => sans Test::Unit)

o Définir les gems
  > in |*NouvelleApp*|/Gemfile
  # Cf. 	
  https://gist.github.com/1344345

o Redéfinir les gems
  # Nécessaire seulement si `rails new` a installé les gems par défaut (= si
  # le Gemfile a été modifié)
  $ sudo bundle install

o Configuration de l'application
  > |*NouvelleApp*|/config/application.rb
  > Dans :
  >  module NouvelleApp
  >    class Application < Rails::Application
  ...
  # Le dossier /lib n'est plus chargé par défaut
  config.autoload_paths += %W(#{config.root}/lib)
  config.autoload_paths += Dir["#{config.root}/lib/**/"]
  ...
  # Si un dossier contient des fichiers requis
  # Par exemple ici les extensions de classes
  Dir[File.join(Rails.root, "lib", "extensions_classes", "*.rb")].each {|l| require l }


  # Pour passer la langue par défaut au français (à décommenter)
  config.i18n.default_locale = :fr
  # Pour qu'il cherche les locales dans tous les sous-dossiers (if any) :
  config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]
  ...
  -> Ajouter :password_confirmation au filtrage des paramètres
  config.filter_parameters += [:password, :password_confirmation]
  ...
  # Pour les mails (+ Devise)
  config.action_mailer.default_url_options = { :host => 'localhost:3000' }
  ...
  # Utilisation des modules de tests
  config.generators do |g|
    g.test_framework :rspec, :views => false, :fixture => true
    g.fixture_replacement :factory_girl, :dir => 'spec/factories'
    g.form_builder :simple_form
    g.template_engine :haml
  end
  ...
  # Si l'application est déployée sur Heroku, ajouter et décommenter :
  # config.assets.initialize_on_precompile = false
  ...

o Supprimer les messages asset (Terminal)
  Si vous n'avez pas envie de voir tous les messages des types :
    Started GET "/assets/etc."
    Served asset etc.
  … dans le Terminal dès que vous lancez une requête :

  > |*NouvelleApp*|/config/environment/development.rb
  > Mettre
  config.assets.debug = false
  # (true par défaut)

o Se placer dans le dossier de l'application
  $ cd NouvelleApp/

o Installation des modules de test
  # rails g = rails generate
  $ rails g cucumber:install --rspec
  $ rails g rspec:install
  $ rails g simple_form:install

o Installation de Devise pour l'authentification et création des vues
  $ rails g devise:install
  $ rails g devise:views
    # Cette génération produit de nouvelles routes qu'on peut voir avec :
    # bundle exec rake routes

o Fichiers ignorés pas Git
  $ mate .gitignore
  => Ouvrir le fichier `.gitignore` dans TextMate

  o Ajouter les fichiers/dossier à ignorer dans .gitignore, dont (si Mac)
  .DS_STORE

o Initier un dépôt Git
  $ git init
  $ git add .
  $ git commit -m "Premier message de dépôt"

o Créer un nouveau dépôt à distance sur github en rejoignant l'adresse :
  https://github.com/repositories/new

o Faire le premier push de l'application vers le dépôt distant
  # |*NouvelleApp*| doit être replacé ci-dessous par le nom donné
  # sur github, s'il est différent du nom de l'application locale
  $ git remote add origin git@github.com:PhilippePerret/|*NouvelleApp*|.git
  $ git push -u origin master
  => Fait le premier push (dépôt) de l'application à distance

o Créer le module utilisateur pour/par devise
  $ rails g devise User[? name:string?]
  # `name:string` doit être ajouté si on veut un nom pour authentifier
  # l'utilisateur

o Faire une première migration de la base de données
  $ bundle exec rake db:migrate

o Préparer la Base de données pour les tests
  $ bundle exec rake db:test:prepare

o Lancer l'application sur le port 3000
  $ rails s   POUR ->  $ rails server

o Voir l'application (pour le moment, le fichier public/index.html)
  <> Dans Firefox, taper l'adresse :
  http://localhost:3000
  => Le fichier par défaut public/index.html s'affiche

o Modification du modèle User (Devise)
  # Si name:string a été ajouté ci-dessus
  -> ajouter `:name` aux attr_accessible :
  attr_accessible :name, :email, etc.
  # Si name:string a été utilisé
  validates :name, :presence => true, :uniqueness => true

  validates :email, :presence => true, :uniqueness => true

o Création d'un utilisateur fictif pour test de Devise
  > in db/seed.rb
  puts "Création d'utilisateurs lambda"
  user_lambda = User.create! :name => "Quelquun", :email => "email@chez.lui", :password => "motdepasse", :password_confirmation => "motdepasse"
  puts "Utilisateur créé : " << user_lambda.name

o Ajouter l'utilisateur dans la base de données
  Et dans la base de données pour les tests
  $ bundle exec rake db:seed
  $ RAILS_ENV=test bundle exec rake db:seed

o Création du contrôleur Users (pour Devise) avec une action `show`
  $ rails g controller Users show

o Modifier la définition des routes
  -> Remplacer :
  get 'users/show'
  -> par :
  resources :users, :only => :show

o Pouvoir afficher l'utilisateur

  > in app/controllers/users.rb
  ...
  before_filter :authenticate_user!
  ...
  def show
    @user = User.find(params[:id])
  end
  ...

  > in app/views/users/show.html.haml
  -> quelque chose comme :
  %p
    Utilisateur : #{@user.name}

ooo Création des vues utiles à Devise

  -> Créer le dossier `app/views/devise/registrations/`
  -> Créer le fichier `app/views/devise/registrations/edit.html.haml
     Y copier le contenu de : https://gist.github.com/1354514
  -> Créer le fichier `app/views/devise/registrations/new.html.haml
     Y copier le contenu de : https://gist.github.com/1354516

ooo Pour Rspec

  -> Créer le dossier `spec/support/`
  -> Créer le fichier `spec/support/devise.rb`
  -> Ajouter :
  > in spec/support/devise.rb
  RSpec.configure do |config|
    config.include Devise::TestHelpers, :type => :controller
  end

ooo Fichiers/dossiers des locales
  > in config/locales
  -> Créer le dossier 'devise'
  -> Y mettre le fichier 'config/devise.en.yml' en le renommant 'en.yml'
  -> Créer le fichier 'config/devise/fr.yml
  -> Créer le dossier 'simple_form'
  -> Y mettre le fichier 'config/simple_form.en.yml' en le renommant 'en.yml'
  -> Créer le fichier 'config/simple_form/fr.yml'
  -> Créer le dossier 'generales' # ou autre nom
  -> Y mettre le fichier 'en.yml'
  -> Créer le fichier 'config/generales/fr.yml'

  Renseigner ces différents fichiers avec les valeurs locales
  # Penser à redémarrer le serveur pour prendre en compte ces
  # nouveaux dossiers
  $ [Ctrl] + C # pour stopper le serveur
  $ rails s    # pour relancer le serveur

ooo Locales qui peuvent être utiles
  # cf. le fichier :
  https://gist.github.com/1566235  # Pour les dates

ooo Réglage du seed
  > in db/seeds.rb

  # Pour resetter la base de données à chaque seed
  # Note : la constante MODE_SANS_RESET doit être définie en haut du
  # fichier seed (ou autre part) et être mise à true si on ne veut
  # pas tout initialiser. Dans lequel cas il faudra "purger" les tables
  # séparément (cf. ci-dessous).
  unless MODE_SANS_RESET
    Rake::Task['db:reset'].invoke
  end
  # Méthode pour purger une table (en la réinitialisation vraiment)
  # en mode développement et test avec sqlite
  def truncate_table_sqlite nom_table
    ActiveRecord::Base.connection.execute("DELETE FROM #{nom_table}")
    ActiveRecord::Base.connection.execute("DELETE FROM sqlite_sequence \
        where name='#{nom_table}'")
    ActiveRecord::Base.connection.execute("VACUUM")  
  end
  # Pour réinitialiser une table, il suffit d'appeler la fonction ci-dessus
  # avec le nom (pluriel) de la table.

  # Ensemble réel
  # > in db/seeds.rb

  CREER_VILLES = true
  MODE_SANS_RESET = true   # La base de sera pas réinitialisée globalement

  creer_les_villes if CREER_VILLES

  def creer_les_villes

    truncate_table_sqlite 'villes'

    ... ici on ajoute les villes à la table réinitialisée ...

  end

  
#--------------------------------------------------------------------------
# OPTIONNEL
#

# Pour des cron jobs (opérations de maintenance régulières)
  $ bundle exec wheneverize .
  => Crée le fichier `config/schedule.rb` permettant de définir les
     cron jobs


# Création d'un contrôleur `Pages` pour afficher autre chose que le
# fichier `public/index.html` par défaut

o Détruire le fichier par défaut
  $ rm public/index.html

o Générer un contrôleur de pages avec une action (page) `accueil`
  qui servira d'accueil à l'application (= accueil du site)
  $ rails g controller Pages accueil
  => Rails crée tous les fichiers nécessaires

o Définir la route par défaut pour que la page accueil s'affiche par défaut
  > in config/routes.rb
  -> Trouver la ligne commenté commençant par `root :to =>`
  -> La décommenter et la remplacer par :
  root :to => "pages#accueil"

o Modifier le fichier `app/views/pages/accueil.html.haml`
  ou le garder tel quel est recharger la page `http://localhost:3000` dans
  le navigateur pour voir la nouvelle page d'accueil.