Comment puis-je passer les arguments de ligne de commande à une tâche rake?

Question

J'ai une tâche rake que je suis de décisions qui besoin d'insérer une valeur dans plusieurs bases de données.

Je voudrais être en mesure de passer à cette valeur dans la tâche rake à partir de la ligne de commande, ou à partir d'une autre tâche rake, comment puis-je faire cela?

Answer 1

Vous pouvez spécifier des arguments formels de rake par l'ajout de symbole d'arguments à la tâche d'appel. Par exemple:

require 'rake'

task :my_task, [:arg1, :arg2] do |t, args|
  puts "Args were: #{args}"
end

task :invoke_my_task do
  Rake.application.invoke_task("my_task[1, 2]")
end

# or if you prefer this syntax...
task :invoke_my_task_2 do
  Rake::Task[:my_task].invoke(3, 4)
end

# a task with prerequisites passes its 
# arguments to it prerequisites
task :with_prerequisite, [:arg1, :arg2] => :my_task

# to specify default values, 
# we take advantage of args being a Rake::TaskArguments object
task :with_defaults, :arg1, :arg2 do |t, args|
  args.with_defaults(:arg1 => :default_1, :arg2 => :default_2)
  puts "Args with defaults were: #{args}"
end

Puis, à partir de la ligne de commande:

> râteau my_task[1,2]
Les arguments étaient les suivants: {:arg1=>"1", :arg2=>"2"}

> râteau "my_task[1, 2]"
Les arguments étaient les suivants: {:arg1=>"1", :arg2=>"2"}

> râteau invoke_my_task
Les arguments étaient les suivants: {:arg1=>"1", :arg2=>"2"}

> râteau invoke_my_task_2
Les arguments étaient les suivants: {:arg1=>3, :arg2=>4}

> râteau with_prerequisite[5,6]
Les arguments étaient les suivants: {:arg1=>"5", :arg2=>"6"}

> râteau with_prerequisite_2[7,8]
Les arguments étaient les suivants: {:arg1=>"7", :arg2=>"8"}

> râteau with_defaults
Args avec les valeurs par défaut ont été: {:arg1=>:default_1, :arg2=>:default_2}

> râteau with_defaults['x','y']
Args avec les valeurs par défaut ont été: {:arg1=>"x", :arg2=>"y"}

Comme démontré dans le deuxième exemple, si vous souhaitez utiliser les espaces, les guillemets autour du nom de la cible sont nécessaires pour maintenir la coquille de l'éclatement des arguments à l'espace.

En regardant le code de la rake.rb, il semble que le râteau de ne pas analyser la tâche de chaînes de caractères à extraire des arguments pour conditions préalables, de sorte que vous ne pouvez pas faire task :t1 => "dep[1,2]". Le seul moyen de spécifier des arguments différents pour une condition préalable serait d'invoquer explicitement dans la tâche dépendante de l'action, comme en :invoke_my_task et :invoke_my_task_2.

Notez que quelques coquilles (comme zsh) vous obliger à s'échapper des supports: rake my_task\['arg1'\]

Answer 2

En plus de répondre par kch (je n'ai pas trouvé comment laisser un commentaire, désolé):

Vous n'avez pas à spécifier les variables ENV variables avant l' rake commande. Vous pouvez juste comme d'habitude paramètres de ligne de commande comme ceci:

rake mytask var=foo

et l'accès à ceux de rake fichier en tant que variables d'environnement comme tel:

p ENV['var'] # => "foo"

Answer 3

Si vous souhaitez passer des arguments nommés (par exemple avec la norme OptionParser) et les rampes d'accès des modèles vous pouvez utiliser quelque chose comme ceci:

$ rake user:create -- --user test@example.com --pass 123

remarque l' --, ce qui est nécessaire pour contourner la norme de râteau arguments.

require 'rake'
require 'optparse'
# Rake task for creating an account

namespace :user do |args|
  desc 'Creates user account with given credentials: rake user:create'
  # environment is required to have access to Rails models
  task :create => :environment do
    options = {}
    OptionParser.new(args) do |opts|
      opts.banner = "Usage: rake user:create [options]"
      opts.on("-u", "--user {username}","User's email address", String) do |user|
        options[:user] = user
      end
      opts.on("-p", "--pass {password}","User's password", String) do |pass|
        options[:pass] = pass
      end
    end.parse!

    puts "creating user account..."
    u = User.new
    u.email = options[:user]
    u.password = options[:pass]
    u.save!
    exit("account created.")
  end
end

exit à la fin vous devrez assurez-vous que les arguments supplémentaires ne sont pas interprétés comme tâche rake.

Lorsque râteau scripts ressembler à ceci, c'est peut-être temps de chercher un autre outil qui permettrait à cette juste hors de la boîte.

Answer 4

J'ai trouvé la réponse à partir de ces deux sites web: Net Maniaque et Aimred.

Vous devez disposer de la version > 0,8 râteau à utiliser cette technique

Le râteau normal description de la tâche est ceci:

desc 'Task Description'
task :task_name => [:depends_on_taskA, :depends_on_taskB] do
  #interesting things
end

Pour passer des arguments, faire trois choses:

1. Ajouter les noms d'argument après le nom de la tâche, séparés par des virgules.
2. Mettre les dépendances à la fin à l'aide de :besoins => [...]
3. Lieu |t, args| après le faire. (t est l'objet de cette tâche)

Pour accéder aux arguments du script, l'utilisation args.arg_name

desc 'Takes arguments task'
task :task_name, :display_value, :display_times, :needs => [:depends_on_taskA, :depends_on_taskB] do |t, args|
  args.display_times.to_i.times do
    puts args.display_value
  end
end

Pour appeler cette tâche à partir de la ligne de commande, passer les arguments de []s

rake task_name['Hello',4]

seront de sortie

Hello
Hello
Hello
Hello

et si vous voulez appeler cette tâche à partir d'une autre tâche, et lui passer des arguments, l'utilisation invoquer

task :caller do
  puts 'In Caller'
  Rake::Task[:task_name].invoke('hi',2)
end

la commande

rake caller

seront de sortie

In Caller
hi
hi

Je n'ai pas trouvé un moyen de passer des arguments dans le cadre d'une dépendance, comme le code suivant pauses:

task :caller => :task_name['hi',2]' do
   puts 'In Caller'
end

Answer 5

Une autre option généralement utilisée est de passer des variables d'environnement. Dans votre code, vous lire grâce à une ENV['VAR'], et peut les transmettre à droite avant l' rake de commande, comme

$ VAR=foo rake mytask