Standardaufgabe für den Namespace in Rake

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)?

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'.

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

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.

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 .

Ich lese die Frage von obvio171 so, dass er ¹⁾ 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

¹⁾ ... oder fragte vor Jahren. Trotzdem eine noch interessante Frage.

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.

Basierend auf Rockys Lösung Standardaufgabe für den Namespace in Rake

Und die Antwort dieses Dexters Gibt es eine Möglichkeit, die aktuelle Rechenaufgabe zu kennen?

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

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.