Ajout d'un répertoire à $LOAD_PATH (Ruby)

Question

J'ai vu deux techniques couramment utilisées pour ajouter le répertoire du fichier en cours d'exécution au $LOAD_PATH (ou $ :). Je vois les avantages de faire cela dans le cas où vous ne travaillez pas avec une gemme. L'une semble plus verbeuse que l'autre, évidemment, mais y a-t-il une raison de choisir l'une plutôt que l'autre ?

La première méthode, verbeuse (pourrait être excessive) :

$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))

et le plus direct, le plus rapide et le plus sale :

$:.unshift File.dirname(__FILE__)

Y a-t-il une raison de choisir l'un plutôt que l'autre ?

Answer 1

Le chemin de chargement de Ruby est très souvent écrit comme $ : mais ce n'est pas parce qu'il est court qu'il est meilleur. Si vous préférez la clarté à l'intelligence, ou si la brièveté pour elle-même vous démange, vous n'avez pas besoin de le faire juste parce que tout le monde le fait. Dites bonjour à ...

$LOAD_PATH

... et dire au revoir à ...

# I don't quite understand what this is doing...
$:

Answer 2

Je dirais que c'est $:.unshift File.dirname(__FILE__) sur l'autre, simplement parce que j'en ai vu beaucoup plus d'utilisation dans le code que la $LOAD_PATH un, et il est plus court aussi !

Answer 3

Je n'aime pas trop la méthode "vite fait bien fait". Quiconque découvre Ruby se demandera ce qu'il faut faire $:. est.

Je trouve cela plus évident.

libdir = File.dirname(__FILE__)
$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)

Ou si je tiens à avoir le chemin complet...

libdir = File.expand_path(File.dirname(__FILE__))
$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)

UPDATE 2009/09/10

Ces derniers temps, j'ai fait ce qui suit :

$:.unshift(File.expand_path(File.dirname(__FILE__))) unless
    $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))

Je l'ai vu dans tout un tas de projets ruby différents en parcourant GitHub.

Il semble que ce soit la convention ?

Answer 4

La meilleure solution que j'ai trouvée pour ajouter un répertoire via un chemin relatif lorsque l'on utilise Rspec. Je trouve que c'est assez verbeux, mais que c'est aussi un bon moyen d'expression.

$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))

Answer 5

Si vous tapez script/console dans votre projet Rails et entrez $: vous obtiendrez un tableau contenant tous les répertoires nécessaires au chargement de Ruby. L'enseignement de ce petit exercice est que $: est un tableau. Cela étant, vous pouvez exécuter des fonctions sur ce tableau, par exemple en faisant précéder d'autres répertoires de la balise unshift ou la méthode << opérateur. Comme vous l'avez laissé entendre dans votre déclaration $: et $LOAD_PATH sont les mêmes.

L'inconvénient de la méthode rapide et sale que vous avez mentionnée est le suivant : si vous avez déjà le répertoire dans votre chemin de démarrage, il se répétera.

Exemple :

J'ai créé un plugin appelé todo. Mon répertoire est structuré comme suit :

/---vendor
  |
  |---/plugins
        |
        |---/todo
              |
              |---/lib
                    |
                    |---/app
                          |
                          |---/models
                          |---/controllers
              |
              |---/rails
                    |
                    |---init.rb

Dans le fichier init.rb, j'ai entré le code suivant :

## In vendor/plugins/todo/rails/init.rb
    %w{ models controllers models }.each do |dir|
      path = File.expand_path(File.join(File.dirname(__FILE__), '../lib', 'app', dir))
      $LOAD_PATH << path
      ActiveSupport::Dependencies.load_paths << path
      ActiveSupport::Dependencies.load_once_paths.delete(path)
    end 

Remarquez comment je demande au bloc de code d'exécuter les actions à l'intérieur du bloc sur les chaînes "models", "controllers" et "models", où je répète "models". (FYI, %w{ ... } est juste une autre façon de dire à Ruby de contenir un tableau de chaînes de caractères). Lorsque je lance script/console je tape ce qui suit :

>> puts $:

Et je tape cela pour qu'il soit plus facile de lire le contenu de la chaîne. La sortie que j'obtiens est :

...
...
./Users/Me/mySites/myRailsApp/vendor/plugins/todo/lib/app/models
./Users/Me/mySites/myRailsApp/vendor/plugins/todo/lib/app/controllers
./Users/Me/mySites/myRailsApp/vendor/plugins/todo/lib/app/models

Comme vous pouvez le constater, bien qu'il s'agisse d'un exemple aussi simple que celui que j'ai pu créer en utilisant un projet sur lequel je travaille actuellement, si vous ne faites pas attention, la méthode rapide et sale mènera à des chemins répétés. La méthode plus longue vérifie les chemins répétés et s'assure qu'ils ne se produisent pas.

Si vous êtes un programmeur Rails expérimenté, vous avez probablement une très bonne idée de ce que vous faites et ne commettez probablement pas l'erreur de répéter des chemins. Si vous êtes un débutant, j'opterais pour le chemin le plus long jusqu'à ce que vous compreniez vraiment ce que vous faites.