Standardaufgabe für den Namespace in Rake

87

Gegeben etwas wie:

namespace :my_tasks do
  task :foo do
    do_something
  end

  task :bar do
    do_something_else
  end

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

Wie mache ich :alldie Standardaufgabe, damit das Ausführen rake my_taskssie aufruft (anstatt aufrufen zu müssen rake my_tasks:all)?

Helder S Ribeiro
quelle
Haben Sie versucht, einen Standard in den Namespace einzufügen (Aufgabe: Standard =>: alle)
Jim Deville
Tun Sie, was Jim beschreibt. Nur die Standardaufgabe geht außerhalb des Namespace und muss den Namespace und den Aufgabennamen enthalten. (task: default => "my_tasks: all") Ein funktionierendes Beispiel finden Sie in meiner Antwort unten.
Randy Eppinger

Antworten:

86

Platzieren Sie es wie folgt außerhalb des Namespace:

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

Auch ... wenn Ihre Aufgaben Argumente erfordern, dann:

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

Beachten Sie, wie Sie im zweiten Beispiel die Aufgabe mit demselben Namen wie den Namespace aufrufen können, dh 'my_tasks'.

Szymon Lipiński
quelle
4
Das macht es nur verfügbar, um als aufgerufen zu werden rake all. In diesem Fall habe ich andere Namespaces. Ich möchte also die Aufgabe my_tasks:allals rake my_tasks, nicht als aufrufen können rake all.
Helder S Ribeiro
53
Verwenden Sie dann einfach: task: my_tasks => ["my_tasks: foo", "my_tasks: bar"]
Szymon Lipiński
2
Als ich für Simons Kommentar gestimmt hatte, hatte ich vergessen, dass ich das so mache.
Jim Deville
51

Nicht sehr intuitiv, aber Sie können einen Namespace und eine Aufgabe haben, die denselben Namen haben und die Ihnen effektiv das geben, was Sie wollen. Zum Beispiel

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

Jetzt können Sie Befehle ausführen wie:

rake my_task:foo

und

rake my_task
Shyam Habarakada
quelle
3
Das ist großartig und deckt alle in der Frage genannten Anforderungen ab.
Ivar
1
Ich denke, der Aufruf ist zu kompliziert und es sollten nur Aufgabenabhängigkeiten sein:task :my_task => ['my_task:foo', 'my_task:bar']
Alexander Presber
8

Ich empfehle Ihnen, dies zu verwenden, wenn Sie viele Aufgaben im Namespace haben.

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

Und dann können Sie alle Aufgaben im Namespace ausführen, indem Sie:

rake my_tasks

Damit müssen Sie sich keine Sorgen mehr machen, um Ihre: all-Aufgabe zu ändern, wenn Sie diesem Namespace neue Aufgaben hinzufügen.

Felsig
quelle
3

Ich benutze dieses Rakefile für Gurken:

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"

Wenn ich dann nur tippe:

rake

Es wird die Standardaufgabe ausgeführt, die sowohl schnelle als auch langsame Tests ausführt.

Ich lernte diese aus Cheezy Blog .

Randy Eppinger
quelle
3

Ich lese die Frage von obvio171 so, dass er 1) nach einer systematischen Methode fragt , um eine bestimmte Aufgabe in einem Namespace aufzurufen, indem er den Namespace als Aufgabe aufruft.

Ich bin häufig auf das gleiche Bedürfnis gestoßen. Ich mag es, Aufgaben logisch in Namespaces zu gruppieren. Oft ähnelt diese Gruppierung einer Hierarchie. Daher ist der Wunsch, die Gruppe anzurufen, für mich sehr sinnvoll.

Hier ist meine Einstellung:

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

1) ... oder fragte vor Jahren. Trotzdem eine noch interessante Frage.

zor-el
quelle
1

Fügen Sie die folgende Aufgabe außerhalb des Namespace hinzu:

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

Beachten Sie, dass Sie eine Aufgabe mit demselben Namen wie der Namespace haben können.

Und hier ein größeres Beispiel, das zeigt, wie Sie Aufgaben verwenden können, die denselben Namen wie der Namespace haben, auch wenn Sie Namespaces verschachteln:

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]

Kopieren Sie es einfach und probieren Sie es aus.

tvw
quelle
0

Die Kombination der Antworten von Szymon Lipiński und Shyam Habarakada ist meiner Meinung nach die idiomatischste und konsequenteste Antwort:

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

Ermöglicht dies, rake my_taskswährend Sie das umständliche Aufrufen der Unteraufgaben vermeiden.

Alexander Presber
quelle