Attività predefinita per lo spazio dei nomi in Rake

Dato qualcosa di simile:

namespace :my_tasks do
  task :foo do
    do_something
  end

  task :bar do
    do_something_else
  end

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

Come faccio a rendere :alll'attività predefinita, in modo che l'esecuzione rake my_tasksla chiamerà (invece di dover chiamare rake my_tasks:all)?

Posizionalo fuori dallo spazio dei nomi in questo modo:

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"]

Inoltre ... se le tue attività richiedono argomenti, allora:

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

Nota come nel 2 ° esempio puoi chiamare l'attività con lo stesso nome dello spazio dei nomi, cioè "my_tasks"

Non molto intuitivo, ma puoi avere uno spazio dei nomi e un'attività che hanno lo stesso nome e che ti danno effettivamente ciò che desideri. Per esempio

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

Ora puoi eseguire comandi come,

rake my_task:foo

e

rake my_task

Ti suggerisco di usarlo se hai molte attività nello spazio dei nomi.

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

E poi puoi eseguire tutte le attività nello spazio dei nomi:

rake my_tasks

Con questo, non devi preoccuparti di modificare la tua attività: all quando aggiungi nuove attività in quello spazio dei nomi.

Uso questo Rakefile per il cetriolo:

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"

Quindi se digito solo:

rake

Esegue l'attività predefinita, che esegue test veloci e lenti.

Ho imparato questo da blog di Cheezy .

Il modo in cui sto leggendo la domanda di obvio171 è che sta chiedendo ¹⁾ un modo sistematico per invocare una determinata attività in uno spazio dei nomi invocando lo spazio dei nomi come un'attività.

Ho riscontrato spesso la stessa esigenza. Mi piace raggruppare logicamente le attività in spazi dei nomi. Spesso quel raggruppamento assomiglia a una gerarchia. Quindi il desiderio di invocare il gruppo ha molto senso per me.

Ecco la mia opinione:

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

¹⁾ ... o chiedevo anni fa. Tuttavia una domanda ancora interessante.

Aggiungi la seguente attività all'esterno dello spazio dei nomi:

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

Tieni presente che puoi avere un'attività con lo stesso nome dello spazio dei nomi.

E un esempio più ampio, che mostra come puoi utilizzare le attività, che hanno lo stesso nome dello spazio dei nomi, anche quando si annidano gli spazi dei nomi:

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]

Basta copiarlo e provarlo.

Basato sulla soluzione Attività predefinita di Rocky per lo spazio dei nomi in Rake

E la risposta di questo Dexter C'è un modo per conoscere l'attuale compito del rake?

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

Combinando le risposte di Szymon Lipiński e Shyam Habarakada, ecco quella che penso sia la risposta più idiomatica e coerente:

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"]

ti permette di fare rake my_tasksevitando ingombranti invocazioni delle sottoattività.