Como executar tarefas Rake de dentro das tarefas Rake?

Eu tenho um Rakefile que compila o projeto de duas maneiras, de acordo com a variável global $build_type, que pode ser :debugou :release(os resultados vão em diretórios separados):

task :build => [:some_other_tasks] do
end

Desejo criar uma tarefa que compila o projeto com as duas configurações, algo como isto:

task :build_all do
  [ :debug, :release ].each do |t|
    $build_type = t
    # call task :build with all the tasks it depends on (?)
  end
end

Existe uma maneira de chamar uma tarefa como se fosse um método? Ou como posso conseguir algo semelhante?

Se você precisa que a tarefa se comporte como um método, que tal usar um método real?

task :build => [:some_other_tasks] do
  build
end

task :build_all do
  [:debug, :release].each { |t| build t }
end

def build(type = :debug)
  # ...
end

Se você preferir manter rakeo idioma, aqui estão suas possibilidades, compiladas a partir de respostas anteriores:

• Isso sempre executa a tarefa, mas não executa suas dependências:

  Rake::Task["build"].execute

• Este executa as dependências, mas somente executa a tarefa se ainda não tiver sido chamado:

  Rake::Task["build"].invoke

• Isso primeiro redefine o estado já_invocado da tarefa, permitindo que a tarefa seja executada novamente, dependências e tudo:

  Rake::Task["build"].reenable
  Rake::Task["build"].invoke

• Observe que as dependências já invocadas não são reexecutadas automaticamente, a menos que sejam reativadas. No Rake> = 10.3.2, você pode usar o seguinte para reativá-los também:

  Rake::Task["build"].all_prerequisite_tasks.each(&:reenable)

por exemplo:

Rake::Task["db:migrate"].invoke

task :build_all do
  [ :debug, :release ].each do |t|
    $build_type = t
    Rake::Task["build"].reenable
    Rake::Task["build"].invoke
  end
end

Isso deveria resolver você, só precisava da mesma coisa.

task :invoke_another_task do
  # some code
  Rake::Task["another:task"].invoke
end

task :build_all do
  [ :debug, :release ].each do |t|
    $build_type = t
    Rake::Task["build"].execute
  end
end

Se você deseja que cada tarefa seja executada independentemente de qualquer falha, você pode fazer algo como:

task :build_all do
  [:debug, :release].each do |t| 
    ts = 0
    begin  
      Rake::Task["build"].invoke(t)
    rescue
      ts = 1
      next
    ensure
      Rake::Task["build"].reenable # If you need to reenable
    end
    return ts # Return exit code 1 if any failed, 0 if all success
  end
end

Eu sugeriria não criar tarefas gerais de depuração e lançamento, se o projeto for realmente algo compilado e resultar em arquivos. Você deve executar tarefas de arquivo, o que é bastante factível no seu exemplo, como você afirma, que sua saída entra em diretórios diferentes. Digamos que seu projeto compila apenas um arquivo test.c para out / debug / test.out e out / release / test.out com o gcc, você pode configurar seu projeto assim:

WAYS = ['debug', 'release']
FLAGS = {}
FLAGS['debug'] = '-g'
FLAGS['release'] = '-O'
def out_dir(way)
  File.join('out', way)
end
def out_file(way)
  File.join(out_dir(way), 'test.out')
end
WAYS.each do |way|
  desc "create output directory for #{way}"
  directory out_dir(way)

  desc "build in the #{way}-way"
  file out_file(way) => [out_dir(way), 'test.c'] do |t|
    sh "gcc #{FLAGS[way]} -c test.c -o #{t.name}"
  end
end
desc 'build all ways'
task :all => WAYS.map{|way|out_file(way)}

task :default => [:all]

Essa configuração pode ser usada como:

rake all # (builds debug and release)
rake debug # (builds only debug)
rake release # (builds only release)

Isso faz um pouco mais, conforme solicitado, mas mostra meus pontos:

1. os diretórios de saída são criados, conforme necessário.
2. os arquivos são recompilados apenas se necessário (este exemplo está correto apenas para os arquivos test.c mais simples).
3. você terá todas as tarefas prontamente em mãos se desejar acionar a versão ou depuração.
4. este exemplo inclui uma maneira de definir também pequenas diferenças entre depuração e compilações de versão.
5. não é necessário reativar uma tarefa de construção parametrizada com uma variável global, porque agora as diferentes construções têm tarefas diferentes. o uso de código da tarefa de construção é feito reutilizando o código para definir as tarefas de construção. veja como o loop não executa a mesma tarefa duas vezes, mas, em vez disso, cria tarefas que podem ser acionadas posteriormente (pela tarefa completa ou pela escolha de uma delas na linha de comando rake).