ruby - ¿Cómo ejecutar tareas de Rake desde tareas de Rake?

Question

Tengo un archivo de Rake que compila el proyecto de dos maneras, de acuerdo con la variable global $build_type , que puede ser :debug o :release (los resultados van en directorios separados):

task :build => [:some_other_tasks] do
end

Deseo crear una tarea que compile el proyecto con ambas configuraciones a su vez, algo como esto:

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

¿Hay una manera de llamar a una tarea como si fuera un método? O ¿cómo puedo lograr algo similar?

Answer 1

Si necesita que la tarea se comporte como un método, ¿qué le parece usar un 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

Si prefieres apegarte a los modismos del rake , aquí están tus posibilidades, compiladas a partir de respuestas pasadas:

• Esto siempre ejecuta la tarea, pero no ejecuta sus dependencias:

  Rake::Task["build"].execute

• Este ejecuta las dependencias, pero solo ejecuta la tarea si aún no ha sido invocado:

  Rake::Task["build"].invoke

• Esto primero restablece el estado ya_invocado de la tarea, permitiendo que la tarea se ejecute de nuevo, las dependencias y todo:

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

  (Observe que las dependencias ya invocadas no se vuelven a ejecutar)

Answer 2

Si desea que cada tarea se ejecute independientemente de cualquier falla, puede hacer 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

Answer 3

Yo sugeriría no crear tareas generales de depuración y liberación si el proyecto es realmente algo que se compila y da como resultado archivos. Debe ir con tareas de archivos, lo que es bastante factible en su ejemplo, ya que establece que su salida va a directorios diferentes. Digamos que su proyecto simplemente compila un archivo test.c para salir / debug / test.out y out / release / test.out con gcc usted podría configurar su proyecto de esta manera:

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]

Esta configuración se puede utilizar como:

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

Esto hace un poco más de lo solicitado, pero muestra mis puntos:

1. Los directorios de salida se crean, según sea necesario.
2. los archivos solo se vuelven a compilar si es necesario (este ejemplo solo es correcto para los archivos de prueba.c más simples).
3. tiene todas las tareas a la mano si desea activar la versión de lanzamiento o la versión de depuración.
4. este ejemplo incluye una forma de definir también pequeñas diferencias entre depuración y compilaciones de lanzamiento.
5. no es necesario volver a habilitar una tarea de compilación que se parametriza con una variable global, porque ahora las diferentes compilaciones tienen tareas diferentes. el uso indebido del código de la tarea de compilación se realiza reutilizando el código para definir las tareas de compilación. vea cómo el bucle no ejecuta la misma tarea dos veces, sino que crea tareas creadas, que luego pueden activarse (ya sea por la tarea completa o al elegir una de ellas en la línea de comandos de rake).

Answer 4

por ejemplo:

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

Answer 5

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

Answer 6

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

Eso debería arreglarte, solo necesitaba lo mismo yo.

Answer 7

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