Share
Les téléchargements de fichiers sont généralement un domaine délicat du développement Web. Dans ce didacticiel, nous allons apprendre à utiliser Dragonfly, un puissant joyau de Ruby qui permet d'ajouter facilement et efficacement tout type de fonctionnalité de téléchargement à un projet Rails..
Notre exemple d'application affichera une liste d'utilisateurs et, pour chacun d'entre eux, nous pourrons télécharger un avatar et le stocker. De plus, Dragonfly nous permettra de:
Dans cette leçon, nous suivrons une approche BDD [Behavior Driven Development], utilisant Cucumber et RSpec..
Imagemagick devra être installé: vous pouvez vous référer à cette page pour les fichiers binaires à installer. Comme je suis basé sur une plate-forme Mac, utilisez Homebrew, je peux simplement taper brasser installer imagemagick.
Vous devrez également cloner une application Rails de base que nous utiliserons comme point de départ..
Nous allons commencer par cloner le référentiel de départ et configurer nos dépendances:
git clone http: //[email protected]/cloud8421/tutorial_dragonfly_template.git cd tutorial_dragonfly_template
Cette application nécessite au moins Ruby 1.9.2 pour fonctionner, cependant, je vous encourage à utiliser 1.9.3. La version de Rails est 3.2.1. Le projet ne comprend pas de .rvmrc ou un .Rbenv fichier.
Ensuite, nous courons:
bundle install bundle exec rake db: setup db: test: prepare db: seed
Cela prendra en charge les dépendances de gemmes et la configuration de la base de données (nous utiliserons sqlite, donc inutile de vous soucier de la configuration de la base de données).
Pour vérifier que tout fonctionne comme prévu, nous pouvons exécuter:
bundle exec rspec bundle exec concombre
Vous devriez constater que tous les tests sont réussis. Passons en revue la sortie de Cucumber:
Fonctionnalité: gestion du profil de l'utilisateur En tant qu'utilisateur Pour gérer mes données, je souhaite accéder à la page de mon profil d'utilisateur. Fond: Un utilisateur existant existe avec le courrier électronique "[email protected]" Scénario: afficher mon profil Vu que je suis sur la page d'accueil Quand Je suis "Profil" pour "[email protected]". Ensuite, je devrais être sur la page de profil pour "[email protected]". Scénario: éditer mon profil Etant donné que je suis sur la page de profil pour "[email protected]" Quand Je suis "Modifier" Et je change mon email avec "[email protected]" Et je clique sur "Enregistrer" Puis je devrais être sur la page de profil pour "[email protected]" Et je devrais voir "Utilisateur mis à jour" 2 scénarios (2 réussies) 11 étapes (11 réussies) 0m0.710s
Comme vous pouvez le constater, ces fonctionnalités décrivent un flux de travail utilisateur typique: nous ouvrons une page utilisateur à partir d’une liste, appuyons sur "Modifier" pour modifier les données utilisateur, modifier le courrier électronique et enregistrer..
Maintenant, essayez de lancer l'application:
rails s
Si vous ouvrez http :: // localhost: 3000 dans le navigateur, vous trouverez une liste d'utilisateurs (nous avons pré-rempli la base de données avec 40 enregistrements aléatoires grâce à la gemme Faker).
Pour l'instant, chacun des utilisateurs aura un petit avatar de 16 x 16 pixels et un grand avatar dans la page de profil. Si vous modifiez l'utilisateur, vous pourrez modifier ses détails (prénom, nom et mot de passe), mais si vous essayez de télécharger un avatar, celui-ci ne sera pas enregistré..
N'hésitez pas à parcourir la base de code: l'application utilise Simple Form pour générer des vues de formulaire et Twitter Bootstrap pour CSS et la mise en page, car ils s'intègrent parfaitement et contribuent grandement à accélérer le processus de prototypage..
Nous allons commencer par ajouter un nouveau scénario à features / managing_profile.feature:
… Scénario: ajout d'un avatar Étant donné que je suis sur la page de profil pour "[email protected]" Quand je suis "Éditer" Et je télécharge l'avatar de moustache Et je clique sur "Enregistrer" Ensuite, je devrais être sur la page de profil pour "email @ example.com "Et le profil devrait afficher" l'avatar de la moustache "
Cette fonctionnalité est assez explicite, mais elle nécessite quelques étapes supplémentaires à ajouter à features / step_definitions / user_steps.rb:
Accentsconagua
… Quand / ^ je télécharge l'avatar moustache $ / do attach_file 'utilisateur [avatar_image]', Rails.root + 'spec / fixtures / moustache_avatar.jpg' end Puis / ^ le profil devrait afficher "([^"] *) " $ / do | image | pattern = image de cas où 'l'avatar de moustache' / moustache_avatar / fin n = Nokogiri :: HTML (page.body) n.xpath (".// img [@ class = 'vignette']") .first ['src']. devrait = ~ fin du motif Cette étape suppose que vous avez une image, appelée moustache_avatar.jpg à l'intérieur spec / fixtures. Comme vous pouvez le deviner, ceci n’est qu’un exemple; Ca peut être tout ce que vous voulez.
La première étape utilise Capybara pour trouver le utilisateur [image_avatar] champ de fichier et télécharger le fichier. Notez que nous supposons que nous aurons un avatar_image attribuer sur le Utilisateur modèle.
La deuxième étape utilise Nokogiri (une puissante bibliothèque d’analyse HTML / XML) et XPath pour analyser le contenu de la page de profil obtenue et rechercher la première. img tag avec un la vignette classe et test que le src attribut contient moustache_avatar.
Si vous courez concombre maintenant, ce scénario déclenchera une erreur, car il n'y a pas de champ de fichier avec le nom que nous avons spécifié. Il est maintenant temps de se concentrer sur Utilisateur modèle.
Avant d’intégrer Dragonfly avec le Utilisateur modèle, ajoutons quelques spécifications à user_spec.rb.
Nous pouvons ajouter un nouveau bloc juste après le les attributs le contexte:
contexte "attributs d'avatar" do it devrait respond_to (: avatar_image) il devrait allow_mass_assignment_of (: avatar_image) end
Nous testons que l'utilisateur a un avatar_image attribut et, comme nous mettrons à jour cet attribut via un formulaire, il doit être accessible (deuxième spécification).
Maintenant, nous pouvons installer Dragonfly: en faisant cela, nous obtiendrons ces spécifications pour passer au vert.
Ajoutons les lignes suivantes au fichier Gemfile:
gem 'rack-cache', nécessite: 'rack / cache' gem 'libellule', '~> 0.9.10'
Ensuite, nous pouvons courir installation groupée. Rack-cache est nécessaire dans le développement, car c’est l’option la plus simple de mettre en cache HTTP. Il peut également être utilisé en production, même si des solutions plus robustes (telles que Varnish ou Squid) seraient préférables..
Nous devons également ajouter l'initialiseur Dragonfly. Créons le config / initializers / libellule.rb déposer et ajouter ce qui suit:
require 'libellule' app = Libellule [: images] app.configure_with (: imagemagick) app.configure_with (: rails) app.define_macro (ActiveRecord :: Base,: image_accessor)
C'est la configuration vanille de Dragonfly: elle configure une application Dragonfly et la configure avec le module requis. Il ajoute également une nouvelle macro à ActiveRecord que nous pourrons utiliser pour étendre notre Utilisateur modèle.
Nous devons mettre à jour config / application.rb, et ajoutez une nouvelle directive à la configuration (juste avant la config.generators bloc):
config.middleware.insert 0, 'Rack :: Cache', verbose: true, métastore: URI.encode ("fichier: # Rails.root / tmp / libellule / cache / meta"), entitystore: URI.encode ("fichier: # Rails.root / tmp / libellule / cache / body") sauf si Rails.env.production? config.middleware.insert_after 'Rack :: Cache', 'Dragonfly :: Middleware',: images Sans entrer dans les détails, nous mettons en place Rack :: Cache (sauf pour la production, où il est activé par défaut), et configurer Dragonfly pour l'utiliser.
Nous allons stocker nos images sur disque, cependant, nous avons besoin d’un moyen de suivre l’association avec un utilisateur. L'option la plus simple consiste à ajouter deux colonnes à la table utilisateur avec une migration:
rails g migration add_avatar_to_users avatar_image_uid: string avatar_image_name: bundle de chaînes exec rake db: migrate db: test: prepare
Encore une fois, cela provient directement de la documentation de Dragonfly: nous devons avoir un avatar_image_uid colonne pour identifier de manière unique le fichier avatar et un avatar_image_name pour stocker son nom de fichier d'origine (cette dernière colonne n'est pas strictement nécessaire, mais elle permet la génération d'URL d'images se terminant par le nom de fichier d'origine).
Enfin, nous pouvons mettre à jour le Utilisateur modèle:
classe utilisateur < ActiveRecord::Base image_accessor :avatar_image attr_accessible :email, :first_name, :last_name, :avatar_image…
le image_accessor Cette méthode est mise à disposition par l'initialiseur Dragonfly et nécessite simplement un nom d'attribut. Nous faisons également le même attribut accessible dans la ligne ci-dessous.
Fonctionnement rspec devrait maintenant montrer toutes les spécifications vert.
Pour tester la fonction de téléchargement, nous pouvons ajouter un contexte à utilisateurs_controller_spec.rb dans le Mise à jour PUT bloc:
contexte "image d'avatar" laisser faire! (: image_file) fixture_file_upload ('/ moustache_avatar.jpg', 'image / jpg') contexte "uploader un avatar" faire avant de mettre: update, id: user.id, user: avatar_image: image_file end it "devrait enregistrer l'enregistrement de l'image sur l'utilisateur" do user.reload user.avatar_image_name.should = ~ / moustache_avatar / end end end Nous allons réutiliser le même appareil et créer une maquette pour le téléchargement avec fixture_file_upload.
Comme cette fonctionnalité s'appuie sur Dragonfly, nous n'avons pas besoin d'écrire de code pour le faire passer..
Nous devons maintenant mettre à jour notre vue pour afficher l'avatar. Commençons à partir de la page utilisateur et ouvrons app / views / users / show.html.erb et le mettre à jour avec le contenu suivant:
<% if @user.avatar_image.present? %> <%= image_tag @user.avatar_image.url, class: 'thumbnail' %> <% else %><% end %>
<%= @user.name %>
<%= @user.email %>
<%= link_to 'Edit', edit_user_path(@user), class: "btn" %>
Ensuite, nous pouvons mettre à jour app / views / users / edit.html.erb:
<%= simple_form_for @user, multipart: true do |f| %><% end %><% if @user.avatar_image.present? %> <%= image_tag @user.avatar_image.url, class: 'thumbnail' %> <% else %><%= f.input :avatar_image, as: :file %><%= f.input :first_name %> <%= f.input :last_name %> <%= f.input :email %><%= f.submit 'Save', class: "btn btn-primary" %>
Nous pouvons afficher l'avatar de l'utilisateur par un simple appel à @ user.avatar_image.url. Cela renverra une URL vers une version non modifiée de l'avatar téléchargé par l'utilisateur..
Si vous courez concombre maintenant, vous verrez la fonctionnalité verte. N'hésitez pas à l'essayer dans le navigateur aussi!
Nous comptons implicitement sur CSS pour redimensionner l'image si elle est trop grande pour son conteneur. C'est une approche fragile: notre utilisateur peut télécharger des avatars non carrés ou une très petite image. De plus, nous servons toujours la même image, sans trop nous préoccuper de la taille de la page ou de la bande passante..
Nous devons travailler sur deux domaines différents: ajouter des règles de validation au téléchargement de l'avatar et spécifier la taille et le ratio de l'image avec Dragonfly.
Nous allons commencer par ouvrir le user_spec.rb fichier et ajout d'un nouveau bloc de spécifications:
contexte "attributs d'avatar" do% w (avatar_image held_avatar_image remove_avatar_image) .each do | attr | il devrait répondre_to (attr.to_sym) fin% w (avatar_image held_avatar_image remove_avatar_image) .each do | attr | it should allow_mass_assignment_of (attr.to_sym) end it "devrait valider la taille du fichier de l'avatar" do user.avatar_image = Rails.root + 'spec / fixtures / huge_size_avatar.jpg' user.should_not be_valid # size is> 100 KB end it "doit valider le format de l'avatar" do user.avatar_image = Rails.root + 'spec / fixtures / dummy.txt' user.should_not be_valid end end
Nous testons la présence et autorisons une "affectation en masse" pour des attributs supplémentaires que nous utiliserons pour améliorer le formulaire utilisateur (: held_avatar_image et : remove_avatar_image).
De plus, nous testons également que notre modèle utilisateur n'acceptera pas les gros envois (plus de 200 Ko) et les fichiers qui ne sont pas des images. Dans les deux cas, nous devons ajouter deux fichiers de fixture (une image avec le nom spécifié et dont la taille est supérieure à 200 Ko et un fichier texte avec n'importe quel contenu)..
Comme d'habitude, exécuter ces spécifications ne nous fera pas passer au vert. Mettons à jour le modèle utilisateur pour ajouter ces règles de validation:
… Attr_accessible: email,: prénom,: dernier_nom,: image_avatar,: image_avatar_principale,: image_principale_principale ... validates_size_avatar_image, maximum: 100.kilobytes validates_property: format, de:: avatar_image, dans: [: jpeg,: png, : jpg] validates_property: type_ime, de: avatar_image, dans: ['image / jpg', 'image / jpeg', 'image / png', 'image / gif'], case_sensitive: false
Ces règles sont assez efficaces: notez qu'en plus de vérifier le format, nous vérifions également le type mime pour plus de sécurité. Étant une image, nous autorisons les fichiers jpg, png et gif.
Nos spécifications devraient être dépassées maintenant, il est donc temps de mettre à jour les vues pour optimiser le chargement des images..
Par défaut, Dragonfly utilise ImageMagick pour traiter les images de manière dynamique à la demande. En supposant que nous avons un utilisateur Par exemple, dans l’un de nos points de vue, nous pourrions alors:
<% end %> user.avatar_image.thumb ('100x100'). url utilisateur.avatar_image.process (: niveaux de gris) .url Ces méthodes créeront une version traitée de cette image avec un hachage unique et, grâce à notre couche de mise en cache, ImageMagick sera appelée une seule fois par image. Après cela, l'image sera servie directement à partir du cache.
Vous pouvez utiliser de nombreuses méthodes intégrées ou tout simplement créer la vôtre, la documentation de Dragonfly contient de nombreux exemples..
Revisitons notre utilisateur modifier page et mettre à jour le code de vue:
… <% if @user.avatar_image.present? %> <%= image_tag @user.avatar_image.thumb('400x400#').url, class: 'thumbnail' %> <% else %>… Nous ferons la même chose pour l'utilisateur spectacle page:
… <% if @user.avatar_image.present? %> <%= image_tag @user.avatar_image.thumb('400x400#').url, class: 'thumbnail' %> <% else %>… Nous forçons la taille de l'image à 400 x 400 pixels. le # Ce paramètre indique également à ImageMagick de rogner l’image en gardant une gravité centrale. Vous pouvez voir que nous avons le même code à deux endroits, alors reformulons cela en un partiel appelé views / users / _avatar_image.html.erb
<% if @user.avatar_image.present? %> <%= image_tag @user.avatar_image.thumb('400x400#').url, class: 'thumbnail' %> <% else %> <% end %> Ensuite, nous pouvons remplacer le contenu de la .la vignette conteneur avec un simple appel à:
<%= render 'avatar_image' %>
Nous pouvons faire encore mieux en déplaçant l'argument de pouce hors du partiel. Mettons à jour _avatar_image.html.erb:
& text = Super + cool + avatar "alt =" Avatar super cool "> <% end %>
