Domyślnie zadanie dla nazw prowizji

Question

Biorąc pod uwagę coś takiego:

namespace :my_tasks do 
    task :foo do 
    do_something 
    end 

    task :bar do 
    do_something_else 
    end 

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

Jak zrobić :all być domyślne zadanie, dzięki czemu działa rake my_tasks będzie to nazwać (zamiast zadzwonić rake my_tasks:all)?

Answer 1

Umieść go na zewnątrz przestrzeni nazw tak:

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

... Także jeśli zadania wymagają argumentów następnie:

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 

zauważyć, jak w 2. Przykładowo można nazwać samo zadanie nazwa jako przestrzeń nazw, tj. "moje_tasky"

Answer 2

Niezbyt intuicyjne, ale możesz mieć przestrzeń nazw i zadania o tej samej nazwie, co skutecznie daje ci to, czego chcesz. Na przykład

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 

Teraz można uruchomić poleceń takich jak,

rake my_task:foo 

i

rake my_task 

Answer 3

Używam tego Rakefile dla Ogórek:

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" 

Następnie jeśli wpisuję tylko :

rake 

Uruchamia zadanie domyślne, które wykonuje zarówno szybkie, jak i powolne testy.

Nauczyłem się this od Cheezy's blog.

Answer 4

Proponuję użyć tego, jeśli masz wiele zadań w przestrzeni nazw.

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

a następnie można uruchomić wszystkie zadania w obszarze nazw, których autorem jest:

rake my_tasks 

z tym, że nie trzeba się martwić, aby zmienić: wszystkie zadania podczas dodawania nowych zadań w tym obszarze nazw .

Answer 5

Sposób, w jaki czytam pytanie obvio171, polega na tym, że pyta on: ¹⁾ o systematyczny sposób wywoływania określonego zadania w przestrzeni nazw poprzez wywoływanie przestrzeni nazw jako zadania.

Często spotykałem tę samą potrzebę. Lubię logicznie grupować zadania w przestrzenie nazw. Często ta grupa przypomina hierarchię. Dlatego chęć powołania grupy ma dla mnie bardzo duży sens.

Oto moje ujęcie. Powiedz mi co myślisz.

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 

---

¹⁾ ... albo pytał przed laty. Niemniej jednak nadal interesujące pytanie.

Answer 6

Dodaj następujące zadania poza obszarem nazw:

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

Należy pamiętać, że można mieć zadanie o takiej samej nazwie jak nazw.

I hier większy przykład, który pokazuje, w jaki sposób można skorzystać z zadań, które mają taką samą nazwę jak nazw, nawet gdy gniazdowania nazw:

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] 

Wystarczy skopiować go i go wypróbować.

Answer 7

oparciu o rozwiązania Rocky'ego Default task for namespace in Rake

I odpowiedz Dextera Is there a way to know the current rake task?

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