Jak uruchamiać zadania prowizji z poziomu zadań prowizji?

Mam plik Rakefile, który kompiluje projekt na dwa sposoby, zgodnie ze zmienną globalną $build_type, którą może być :debuglub :release(wyniki znajdują się w osobnych katalogach):

task :build => [:some_other_tasks] do
end

Chcę utworzyć zadanie, które po kolei kompiluje projekt z obiema konfiguracjami, mniej więcej tak:

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

Czy istnieje sposób na wywołanie zadania tak, jakby to była metoda? Lub jak mogę osiągnąć coś podobnego?

Jeśli potrzebujesz, aby zadanie zachowywało się jak metoda, co powiesz na użycie rzeczywistej metody?

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

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

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

Jeśli wolisz trzymać się rakeidiomów, oto twoje możliwości, zebrane na podstawie wcześniejszych odpowiedzi:

• To zawsze wykonuje zadanie, ale nie wykonuje jego zależności:

  Rake::Task["build"].execute

• Ten wykonuje zależności, ale wykonuje zadanie tylko wtedy, gdy nie zostało jeszcze wywołane:

  Rake::Task["build"].invoke

• To najpierw resetuje stan już wywołanego zadania, umożliwiając jego ponowne wykonanie, zależności i wszystkie:

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

• Należy zauważyć, że wywołane już zależności nie są automatycznie ponownie uruchamiane, chyba że zostaną ponownie włączone. W Rake> = 10.3.2 możesz również użyć tych opcji, aby je ponownie włączyć:

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

na przykład:

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

To powinno cię załatwić, sam potrzebowałem tego samego.

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

Jeśli chcesz, aby każde zadanie działało bez względu na awarie, możesz zrobić coś takiego:

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

Sugerowałbym, aby nie tworzyć ogólnych zadań debugowania i zwalniania, jeśli projekt jest tak naprawdę kompilowany, co powoduje powstanie plików. Powinieneś przejść do zadań związanych z plikami, co jest całkiem wykonalne w twoim przykładzie, gdy stwierdzasz, że twoje wyjście trafia do różnych katalogów. Powiedz, że twój projekt po prostu kompiluje plik test.c do out / debug / test.out i out / release / test.out za pomocą gcc, możesz skonfigurować swój projekt w następujący sposób:

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]

Tej konfiguracji można użyć w następujący sposób:

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

Robi to nieco więcej, o co prosiłem, ale pokazuje moje punkty:

1. w razie potrzeby tworzone są katalogi wyjściowe.
2. pliki są rekompilowane tylko w razie potrzeby (ten przykład jest poprawny tylko dla najprostszych plików test.c).
3. masz wszystkie zadania pod ręką, jeśli chcesz uruchomić kompilację wersji lub kompilację debugowania.
4. ten przykład zawiera sposób na zdefiniowanie również niewielkich różnic między kompilacjami debugowania i wydań.
5. nie ma potrzeby ponownego włączania zadania kompilacji sparametryzowanego zmienną globalną, ponieważ teraz różne kompilacje mają różne zadania. użycie kod-kompilacji zadania kompilacji odbywa się poprzez ponowne użycie kodu do zdefiniowania zadań kompilacji. zobacz, jak pętla nie wykonuje tego samego zadania dwa razy, ale zamiast tego utworzyła zadania, które później mogą zostać uruchomione (albo przez wszystkie zadania, albo wybierając jedno z nich w linii poleceń rake).