Langages/Ruby/Rails/HelloWorld

Un article de Agora2ia.


rails.png


Sommaire

Environnement

  • RVM (voir sur la page Rails)
    • Ruby 1.9.3
    • Rails 3.2.3
  • RubyMine pour l'IDE
  • Base de données :
    • SQLite pour les environnements développement et test (car je développe sous Mac et elle est disponible par défaut)
    • PostGre pour la production (car c'est ce qui est utilisé par Heroku)

Cet environnement (à RubyMine et aux version près) est celui utilisé dans le très bon livre Ruby on Rails 3 Tutorial... J'dis ça, j'dis rien...


Mots clefs : Rails, RubyOnRails, Ruby On Rails, RoR

Voir aussi la page Rails


Hosting avec Heroku

Cet article utilise Heroku comme plateforme d'hébergement, gratuite et professionnelle, sachant que Heroku offre bien plus en tant que plateforme SaaS.

Création de l'application

A partir du gestionnaire de version Git

Après avoir créé le repository de votre application myFirstApp sur Github (reposant sur Git),

Obtenir le repository vide créé :

> git clone git@github.com:jacques/myFirstApp

Se positionner dedans :

> cd myFirstApp

Créer immédiatement une branche de développement qui vous permettra de travailler en toute liberté sans risquer de contaminer la branche principale :

> git branch dev

Puis basculer sur cette branche de développement :

> git checkout dev

A tout moment, vous pourrez pousser le contenu de cette branche de développement sans reticence (après un commit) :

> git add .
> git commit -m "Developpement en cours"
> git push -u origin dev


Voir la page Git pour d'avantage de détails...

Création du squelette de l'application

Pour créer le squelette de son application, depuis une console, se mettre dans le répertoire qui va contenir le répertoire racine de l'application :

(ATTENTION : si vous comptez utiliser Heroku ou la base de données PostgreSQL, consultez le paragraphe PostgreSQL comme unique base de données)

> cd /projects
> rails new myFirstApp
> cd myFirstApp


Cela va lancer la création du répertoire racine myFirstApp et de l'arborescence initiale avec les répertoire clefs et les fichiers nécessaires pour débuter.

Une fois dans le répertoire racine myFirstApp, voici les répertoires accessibles :

.
..
app
config
db
doc
lib
log
public
script
test
tmp
vendor

Nous verrons ces différents répertoires par la suite.

Voyons maintenant ce que nous obtenons avec ceci. Lançons un serveur depuis la racine de notre application.

banking> ruby script/server

ou encore (selon la version de rails utilisée) :

banking> ruby script/rails server

Il ne vous reste plus qu'a ouvrir votre browser préféré et y indiquer l'URL de votre application :

http://localhost:3000/

Paramétrer PostgreSQL pour Heroku

La plateforme SaaS Heroku, qui offre permet notamment d'héberger vos applications Rails, fonctionne uniquement avec la BaseDeDonnees PostgreSQL.

Plusieurs possibilités s'offrent à vous quant à l'utilisation de PostgreSQL dans votre application Rails :

  • Seulement en production (et continuation d'utiliser SQLite, la configuration par défaut, en développement et test)
  • Sur tous les environnements.

Voir aussi Setup Rails with Postgresql

PostgreSQL seulement en production

Dans le fichier Gemfile, il faut remplacer la ligne :

gem 'sqlite3'

par :

group :development, :test do
  gem 'sqlite3'
end
group :production do
  gem 'pg' # for Heroku deployment
end


PostgreSQL comme unique base de données

Le plus simple, si vous commencez un projet de zéro, pour avoir une application Rails configurée uniquement pour PostgreSQL est de l'indiquer à la création de l'application :

rails --database=postgresql myapp

ou

rails new --database=postgresql myapp

Remplacer l'index static par défaut

Supprimer le fichier index généré par défaut :

rm public/index.html

Puis générer un controller home> avec une vue pour la page d'accueil index :

rails generate controller home index

Enfin, définir cette vue comme celle racine. Dans le fichier config/routes.rb décommenter la ligne suivante :

root :to => 'home#index'


Voir http://guides.rubyonrails.org/getting_started.html pour d'avantage de détails.


Premières Entités

Créer l'entité User

rails generate scaffold

Générer les ressources pour la nouvelle entité User :

rails generate scaffold User login:string password:string firstName:string lastName:string email:string city:string


On peut aussi utiliser simplement le générateur model : voir l'ajout de l'association Address plus bas.


rake db:migrate

Mettre à jour la base de données par rapport à cette nouvelle entité :

rake db:migrate


rails s

Vous pouvez alors lancer le serveur :

> rails s


Validation des attributs

Contraintes dans la migration

Dans le fichier migration de création ou de mise à jour de l'ActiveRecord ajouter éventuellement des :null => false pour les attributs concernés :

class CreateLaundries < ActiveRecord::Migration
  def change
    create_table :laundries do |t|
      t.string :code,     :null => false
      t.string :name
      t.string :address1, :null => false
      t.string :zip
      t.string :city,     :null => false
      t.string :country,  :null => false
      t.string :web
      t.text   :description
      t.timestamps
    end
  end
end

Et executer les migrations pour mettre à jour la base de données :

rake db:migrate


Validations dans l'ActiveRecord

Ajouter la contrainte validates dans l'ActiveRecord concerné :

class Machine < ActiveRecord::Base
  attr_accessible :name, :kind, :capacity, :status, :description
  validates :name, :kind, :presence => true
 ...
end


Ajout de la zone de message dans la vue

1) Ajouter la dépendance au Gem dynamic_form :

 # DynamicForm provides helpers to display the error messages of your models in your view templates.
 # https://github.com/joelmoss/dynamic_form
 # see f.error_messages helper
 gem "dynamic_form"

Voir https://github.com/joelmoss/dynamic_form

Et l'installer via un terminal positionné à la racine du projet :

bundle install

2) Dans la vue correspondante, _form.html.erb pour nous, ajouter le helper  :

<%= form_for @laundry, :html => { :class => 'form-horizontal' } do |f| %>
    <%= f.error_messages %>
    ...
<% end %>


Un User peut avoir plusieurs Address

Pour ajouter des adresses à tout utilisateur, on peut utiliser le générateur scaffold vu plus haut ou alors le générateur model. Noter au passage une colonne pour la foreign key vers User :

rails g model Address user_id:integer street:string zip:string city:string state:string country:string tel:string

Ce qui va créer la migration /db/migrate/20130630143353_create_addresses.rb.

Il faut ensuite ajouter la relation au niveau des modèles

class Address < ActiveRecord::Base
   attr_accessible :city, :country, :state, :street, :tel, :zip

   belongs_to :company
end

et :

class User < ActiveRecord::Base
   #...
   has_many :adresses, dependent: :destroy
   #...
end

Supprimer une table / ressource

Si vous avez déjà créé la table dans la base via un rake db:migrate il vous faut créer une migration :

rails generate migration Figures
rails destroy scaffold Figure
rails generate scaffold Figure name:string
rake db:migrate


Ajouter une URL pour trouvé une entité par autre chose que son ID

Si nous souhaitons retrouver une Laundry par son code au lieu de son id et donc utiliser l'url :

http://myserver.com/l/laundry_paquis

au lieu de :

http://myserver.com/laundries/1

Il faut 1) modifier le fichier config/route.rb :

match "l/:laundry_code" => "laundries#show"

Puis 2) le controller laundries_controller.rb référencé :


 def show
   if params[:id]
     @laundry = Laundry.find(params[:id])
   elsif params[:laundry_code]
     @laundry = Laundry.find_by_code(params[:laundry_code])
   end
   ....
 end

Authentification

Utilisation de devise

Installation

Dans votre application, compléter le fichier Gemfile :

gem 'devise'

Puis installer le gem via l'une des deux commandes suivantes :

bundle install

ou :

bundle install --path vendor/bundle


Configuration

Cette installation se termine en affichant les 4 étapes suivantes à faire.

  • Compléter les fichiers config/environments/*.rb avec la ligne :
 # Set by using 'devise' for authentication
 config.action_mailer.default_url_options = { :host => 'localhost:3000' }


  • Modifier config/routes.rb avec la ligne :
root :to => "home#index"


  • Modifier app/views/layouts/application.html.erb avec la ligne :
 <p class="notice"><%= notice %></p>
 <p class="alert"><%= alert %></p>
 


  • Modifier config/application.rb avec la ligne (_If you are deploying Rails 3.1 on Heroku_) :
config.assets.initialize_on_precompile = false


  • Mettre à jour votre application avec les fonctionnalités devise :
rails generate devise User


  • Impacter la base de données
rake db:migrate



Améliorations

  • Configurer un serveur mail si vous souhaitez les mails de confirmation (voir ce site)...
  • Modifier les views de devises :
rails generate devise:views
 # views/devise/menu/_login_items.html.erb
 <% if user_signed_in? %>
   <li><%= link_to('Logout', destroy_user_session_path, :method => :delete) %></li>
 <% else %>
   <li><%= link_to('Login', new_user_session_path)  %></li>
 <% end %>
 


Ajouter Twitter Bootstrap

Cette librairie a pour vocation de faciliter la mise en page de votre site, et d'assurer du responsive design.

Voir aussi :


Installation

Ajouter la dépendance dans le fichier Gemfile :

gem 'twitter-bootstrap-rails'

Et l'installer :

bundle install
rails g bootstrap:install

Mettre enfin en place les dépendances :

rails g bootstrap:layout application fixed


Configuration pour une entité

Utiliser la bonne version du gem twitter-bootstrap-rails dans le fichier Gemfile :

gem 'twitter-bootstrap-rails', :git => 'git://github.com/seyhunak/twitter-bootstrap-rails.git'

Puis :

bundle install

Vous pouvez ensuite crééer une entité via le scaffold generator :

rails g scaffold Laundry name:string address:string zip::string city:string

Sans oublier de faire la migration :

rake db:migrate

Appeler alors le generator du gem twitter-bootstrap-rails sur l'entité pour en adapter les vues :

rails g bootstrap:themed Laundries


Upload de fichiers

Une solution consiste à utiliser Amazon S3 avec le gem Paperclip :


Ressources

  • ...