Tâche par défaut pour l'espace de noms dans Rake

Étant donné quelque chose comme:

namespace :my_tasks do
  task :foo do
    do_something
  end

  task :bar do
    do_something_else
  end

  task :all => [:foo, :bar]
end

Comment faire pour que ce :allsoit la tâche par défaut, de sorte que l'exécution rake my_tasksl'appellera (au lieu d'avoir à appeler rake my_tasks:all)?

Placez-le en dehors de l'espace de noms comme ceci:

namespace :my_tasks do
  task :foo do
    do_something
  end

  task :bar do
    do_something_else
  end

end

task :all => ["my_tasks:foo", "my_tasks:bar"]

Aussi ... si vos tâches nécessitent des arguments, alors:

namespace :my_tasks do
  task :foo, :arg1, :arg2 do |t, args|
    do_something
  end

  task :bar, :arg1, :arg2  do |t, args|
    do_something_else
  end

end

task :my_tasks, :arg1, :arg2 do |t, args|
  Rake::Task["my_tasks:foo"].invoke( args.arg1, args.arg2 )
  Rake::Task["my_tasks:bar"].invoke( args.arg1, args.arg2 )
end

Remarquez comment dans le 2ème exemple vous pouvez appeler la tâche le même nom que l'espace de noms, c'est-à-dire 'mes_tâches'

Pas très intuitif, mais vous pouvez avoir un espace de noms et une tâche qui portent le même nom, ce qui vous donne effectivement ce que vous voulez. Par exemple

namespace :my_task do
  task :foo do
    do_foo
  end
  task :bar do
    do_bar
  end
end

task :my_task do
  Rake::Task['my_task:foo'].invoke
  Rake::Task['my_task:bar'].invoke
end

Maintenant, vous pouvez exécuter des commandes comme,

rake my_task:foo

et

rake my_task

Je vous suggère de l'utiliser si vous avez beaucoup de tâches dans l'espace de noms.

task :my_tasks do
  Rake.application.in_namespace(:my_tasks){|x| x.tasks.each{|t| t.invoke}}
end

Et puis, vous pouvez exécuter toutes les tâches dans l'espace de noms en:

rake my_tasks

Avec cela, vous n'avez pas à vous soucier de changer votre tâche: all lorsque vous ajoutez de nouvelles tâches dans cet espace de noms.

J'utilise ce Rakefile pour le concombre:

require 'cucumber'
require 'cucumber/rake/task'

namespace :features do
  Cucumber::Rake::Task.new(:fast) do |t|
    t.profile = 'fast'
  end

  Cucumber::Rake::Task.new(:slow) do |t|
    t.profile = 'slow'
  end

  task :ci => [:fast, :slow]
end

task :default => "features:ci"

Alors si je tape juste:

rake

Il exécute la tâche par défaut, qui exécute des tests rapides et lents.

J'ai appris cela sur le blog de Cheezy .

La façon dont je lis la question d'Obvio171 est qu'il demande ¹⁾ une manière systématique d'appeler une certaine tâche dans un espace de noms en invoquant l'espace de noms en tant que tâche.

J'ai souvent rencontré le même besoin. J'aime regrouper logiquement les tâches dans des espaces de noms. Souvent, ce regroupement ressemble à une hiérarchie. D'où le désir d'invoquer le groupe me semble tout à fait logique.

Voici ma prise:

module Rake::DSL
  def group(name, &block)
    ns = namespace name, &block
    default = ns[:default]
    task name => "#{name}:default" if default
    ns
  end
end

group :foo do
  task :foo1 do |t| puts t.name end
  task :foo2 do |t| puts t.name end
  task :default => [:foo1, :foo2]
end

task :default => :foo

¹⁾ ... ou demandait, il y a des années. Néanmoins, une question toujours intéressante.

Ajoutez la tâche suivante en dehors de l'espace de noms:

desc "Run all my tasks"
task :my_tasks => ["my_tasks:all"]

Gardez à l'esprit que vous pouvez avoir une tâche portant le même nom que l'espace de noms.

Et voici un exemple plus grand, qui montre comment vous pouvez utiliser des tâches, qui ont le même nom que l'espace de noms, même lors de l'imbrication d'espaces de noms:

namespace :job1 do
  task :do_something1 do
        puts "job1:do_something1"
    end

  task :do_something2 do
        puts "job1:do_something2"
    end
  task :all => [:do_something1, :do_something2]
end

desc "Job 1"
task :job1 => ["job1:all"]

# You do not need the "all"-task, but it might be handier to have one.
namespace :job2 do
  task :do_something1 do
        puts "job2:do_something1"
    end

  task :do_something2 do
        puts "job2:do_something2"
    end
end

desc "Job 2"
task :job2 => ["job2:do_something1", "job2:do_something2"]

namespace :superjob do
    namespace :job1 do
        task :do_something1 do
            puts "superjob:job1:do_something1"
        end

        task :do_something2 do
            puts "superjob:job1:do_something2"
        end
    end

    desc "Job 1 in Superjob"
    task :job1 => ["job1:do_something1", "job1:do_something2"]

    namespace :job2 do
        task :do_something1 do
            puts "superjob:job2:do_something1"
        end

        task :do_something2 do
            puts "superjob:job2:do_something2"
        end
    end

    desc "Job 2 in Superjob"
    task :job2 => ["job2:do_something1", "job2:do_something2"]
end

desc "My Super Job"
task :superjob => ["superjob:job1", "superjob:job2"]

# Do them all just by calling "$ rake"
task :default => [:job1, :job2, :superjob]

Copiez-le et essayez-le.

Basé sur la solution de Rocky Tâche par défaut pour l'espace de noms dans Rake

Et la réponse de cette dexter Y a-t-il un moyen de connaître la tâche de râteau actuelle?

namespace :root do
  namespace :foo do
  end

  namespace :target do
    task :all do |task_all|
      Rake.application.in_namespace(task_all.scope.path) do |ns|
        ns.tasks.each { |task| task.invoke unless task.name == task_all.name } 
      end
    end

    task :one do
    end

    task :another do
    end
  end
end

En combinant les réponses de Szymon Lipiński et de Shyam Habarakada, voici ce que je pense être la réponse la plus idiomatique et la plus concise:

namespace :my_tasks do
  task :foo do
    do_something
  end

  task :bar do
    do_something_else
  end

end

task :my_tasks => ["my_tasks:foo", "my_tasks:bar"]

vous permet de le faire rake my_taskstout en évitant l'invocation fastidieuse des sous-tâches.