බහුවිධ දත්ත සමුදායන් තුළට වටිනාකමක් ඇතුළත් කළ යුතු පරස්පර කාර්යයක් මා සතුව ඇත.

මෙම අගය විධාන රේඛාවෙන් හෝ වෙනත් පරාවර්තක කර්තව්‍යයකින් ලබා දීමට මම කැමතියි .

මට මෙය කළ හැක්කේ කෙසේද?

විකල්ප සහ පරායත්තතා අරා තුළ තිබිය යුතුය:

namespace :thing do
  desc "it does a thing"
  task :work, [:option, :foo, :bar] do |task, args|
    puts "work", args
  end

  task :another, [:option, :foo, :bar] do |task, args|
    puts "another #{args}"
    Rake::Task["thing:work"].invoke(args[:option], args[:foo], args[:bar])
    # or splat the args
    # Rake::Task["thing:work"].invoke(*args)
  end

end

ඉන්පසු

rake thing:work[1,2,3]
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}

rake thing:another[1,2,3]
=> another {:option=>"1", :foo=>"2", :bar=>"3"}
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}

සටහන: විචල්‍යය taskයනු කාර්ය වස්තුව වන අතර, ඔබ රේක් අභ්‍යන්තර ගැන දැනගෙන / සැලකිලිමත් නොවන්නේ නම් එය එතරම් ප්‍රයෝජනවත් නොවේ.

රේල්ස් සටහන:

රේල් පීලි වලින් කාර්යය ක්‍රියාත්මක කරන්නේ නම්, යැපෙන කාර්යයන් => [:environment]සැකසීමේ ක්‍රමයක් වන එකතු කිරීමෙන් පරිසරය පූර්ව පැටවීම වඩාත් සුදුසුය .

  task :work, [:option, :foo, :bar] => [:environment] do |task, args|
    puts "work", args
  end

කාර්ය ඇමතුමට සංකේත තර්ක එකතු කිරීමෙන් ඔබට විධිමත් තර්ක රාක්කයේ සඳහන් කළ හැකිය. උදාහරණයක් වශයෙන්:

require 'rake'

task :my_task, [:arg1, :arg2] do |t, args|
  puts "Args were: #{args} of class #{args.class}"
  puts "arg1 was: '#{args[:arg1]}' of class #{args[:arg1].class}"
  puts "arg2 was: '#{args[:arg2]}' of class #{args[:arg2].class}"
end

task :invoke_my_task do
  Rake.application.invoke_task("my_task[1, 2]")
end

# or if you prefer this syntax...
task :invoke_my_task_2 do
  Rake::Task[:my_task].invoke(3, 4)
end

# a task with prerequisites passes its 
# arguments to it prerequisites
task :with_prerequisite, [:arg1, :arg2] => :my_task #<- name of prerequisite task

# to specify default values, 
# we take advantage of args being a Rake::TaskArguments object
task :with_defaults, :arg1, :arg2 do |t, args|
  args.with_defaults(:arg1 => :default_1, :arg2 => :default_2)
  puts "Args with defaults were: #{args}"
end

විධාන රේඛාවෙන්:

> rake my_task [1, අසත්ය]
තර්ක: {: arg1 => "1" ,: arg2 => පංතියේ Rake :: "ව්‍යාජ" :: RaskArguments
arg1 වූයේ: පන්තියේ සංගීතයේ '1' ය
arg2 වූයේ: පන්තියේ සංගීතයේ 'අසත්‍ය' ය

> rake "my_task [1, 2]"
තර්ක: {: arg1 => "1" ,: arg2 => "2"}

> rake invoke_my_task
තර්ක: {: arg1 => "1" ,: arg2 => "2"}

> rake invoke_my_task_2
තර්ක: {: arg1 => 3 ,: arg2 => 4}

> පෙර-අවශ්‍යතා සහිත රාක්කය [5,6]
තර්ක: {: arg1 => "5" ,: arg2 => "6"}

> දෝෂ සහිත_
පෙරනිමි සහිත තර්ක: {: arg1 =>: default_1 ,: arg2 =>: default_2}

> rake with_defaults ['x', 'y']
පෙරනිමි සහිත තර්ක: {: arg1 => "x" ,: arg2 => "y"}

දෙවන උදාහරණයේ පෙන්වා ඇති පරිදි, ඔබට අවකාශය භාවිතා කිරීමට අවශ්‍ය නම්, අවකාශයේ ඇති තර්ක විභේදනය නොකිරීමට ඉලක්ක නාමය වටා ඇති උපුටා දැක්වීම් අවශ්‍ය වේ.

Rake.rb හි කේතය දෙස බලන විට, පූර්වාවශ්‍යතාවයන් සඳහා තර්ක උකහා ගැනීම සඳහා රාක් විසින් කාර්ය නූල් විග්‍රහ නොකරන බව පෙනේ, එබැවින් ඔබට එය කළ නොහැක task :t1 => "dep[1,2]". පූර්ව අවශ්යතාවක් සඳහා විවිධ තර්ක නියම කිරීමට ඇති එකම මාර්ගය වන අයුරින්, රඳා කාර්ය පියවර තුළ නිශ්චිත වශයෙන්ම එය පතා වනු :invoke_my_taskසහ :invoke_my_task_2.

සමහර ෂෙල් වෙඩි (zsh වැනි) ඔබට වරහන් වලින් ගැලවීමට අවශ්‍ය බව සලකන්න: rake my_task\['arg1'\]

Kch විසින් පිළිතුරු දීමට අමතරව (ඒ සඳහා අදහස් දැක්වීමක් කරන්නේ කෙසේදැයි මට හමු නොවීය, සමාවෙන්න):

විධානයට ENVපෙර විචල්යයන් ලෙස විචල්යයන් නියම කිරීමට ඔබට අවශ්ය නැත rake. ඔබට ඒවා සුපුරුදු පරිදි විධාන රේඛා පරාමිතීන් ලෙස සැකසිය හැකිය:

rake mytask var=foo

සහ ඔබේ රාක් ගොනුවෙන් ENV විචල්‍යයන් ලෙස ප්‍රවේශ වන්න:

p ENV['var'] # => "foo"

ඔබට නම් කරන ලද තර්ක සම්මත කිරීමට අවශ්‍ය නම් (උදා: ප්‍රමිතිය සමඟ OptionParser) ඔබට මෙවැනි දෙයක් භාවිතා කළ හැකිය:

$ rake user:create -- --user test@example.com --pass 123

--සම්මත රේක් තර්ක මඟ හැරීම සඳහා එය අවශ්‍ය බව සලකන්න . Rake 0.9.x , <= 10.3.x සමඟ වැඩ කළ යුතුය .

අළුත් රේක් එහි විග්‍රහය වෙනස් කර ඇති --අතර දැන් එය OptionParser#parseක්‍රමයට සම්මත නොවන බවට වග බලා ගත යුතුය.parser.parse!(ARGV[2..-1])

require 'rake'
require 'optparse'
# Rake task for creating an account

namespace :user do |args|
  desc 'Creates user account with given credentials: rake user:create'
  # environment is required to have access to Rails models
  task :create do
    options = {}
    OptionParser.new(args) do |opts|
      opts.banner = "Usage: rake user:create [options]"
      opts.on("-u", "--user {username}","User's email address", String) do |user|
        options[:user] = user
      end
      opts.on("-p", "--pass {password}","User's password", String) do |pass|
        options[:pass] = pass
      end
    end.parse!

    puts "creating user account..."
    u = Hash.new
    u[:email] = options[:user]
    u[:password] = options[:pass]
    # with some DB layer like ActiveRecord:
    # user = User.new(u); user.save!
    puts "user: " + u.to_s
    puts "account created."
    exit 0
  end
end

exit අවසානයේදී අතිරේක තර්ක රාක් කර්තව්‍යයක් ලෙස අර්ථ නිරූපණය නොකිරීමට වග බලා ගනී.

තර්ක සඳහා කෙටිමඟ ද ක්‍රියා කළ යුතුය:

 rake user:create -- -u test@example.com -p 123

රාක් ස්ක්‍රිප්ට් මේ ආකාරයට පෙනෙන විට, සමහර විට මෙය කොටුවෙන් පිටතට යාමට ඉඩ දෙන වෙනත් මෙවලමක් සෙවීමට කාලයයි.

මම මෙම වෙබ් අඩවි දෙකෙන් පිළිතුර සොයාගෙන ඇත: Net Maniac සහ Aimred .

මෙම තාක්ෂණය භාවිතා කිරීම සඳහා ඔබට අනුවාදය> 0.8 රාක් තිබිය යුතුය

සාමාන්‍ය පරාවර්තක කාර්ය විස්තරය මෙයයි:

desc 'Task Description'
task :task_name => [:depends_on_taskA, :depends_on_taskB] do
  #interesting things
end

තර්ක ඉදිරිපත් කිරීමට, කරුණු තුනක් කරන්න:

1. කොමා මඟින් වෙන් කරන ලද කාර්ය නාමයෙන් පසුව තර්ක නම් එකතු කරන්න.
2. පහත දැක්වෙන පරායත්තයන් භාවිතා කරන්න: අවශ්‍යතා => [...]
3. ස්ථානය | ටී, ආර්ග් | කළ පසු. (t යනු මෙම කාර්යයේ පරමාර්ථයයි)

ස්ක්‍රිප්ටයේ ඇති තර්ක වෙත ප්‍රවේශ වීමට, args.arg_name භාවිතා කරන්න

desc 'Takes arguments task'
task :task_name, :display_value, :display_times, :needs => [:depends_on_taskA, :depends_on_taskB] do |t, args|
  args.display_times.to_i.times do
    puts args.display_value
  end
end

විධාන රේඛාවෙන් මෙම කාර්යය ඇමතීමට, එය [] හි ඇති තර්ක ඉදිරිපත් කරන්න

rake task_name['Hello',4]

ප්‍රතිදානය කරයි

Hello
Hello
Hello
Hello

ඔබට මෙම කාර්යය වෙනත් කාර්යයකින් ඇමතීමට අවශ්‍ය නම් සහ එය තර්ක ඉදිරිපත් කිරීමට නම්, ඉන්වොක් භාවිතා කරන්න

task :caller do
  puts 'In Caller'
  Rake::Task[:task_name].invoke('hi',2)
end

ඉන්පසු විධානය

rake caller

ප්‍රතිදානය කරයි

In Caller
hi
hi

පහත දැක්වෙන කේතය කැඩී යන බැවින් පරායත්තතාවයේ කොටසක් ලෙස තර්ක ඉදිරිපත් කිරීමට මට ක්‍රමයක් හමු නොවීය:

task :caller => :task_name['hi',2]' do
   puts 'In Caller'
end

බහුලව භාවිතා වන තවත් විකල්පයක් වන්නේ පරිසර විචල්‍යයන් සමත් වීමයි. ඔබේ කේතයේ දී ඔබ ඒවා හරහා කියවන අතර , වැනි විධානයට ENV['VAR']පෙර ඒවා යැවිය හැකියrake

$ VAR=foo rake mytask

තර්ක විතර්ක කරන්නේ කෙසේදැයි මට සිතාගත නොහැකි විය: මම මෙය සකස් කරන තුරු පරිසරය:

namespace :db do
  desc 'Export product data'
  task :export, [:file_token, :file_path] => :environment do |t, args|
    args.with_defaults(:file_token => "products", :file_path => "./lib/data/")

       #do stuff [...]

  end
end

ඊට පස්සේ මම මේ වගේ කතා කරනවා:

rake db:export['foo, /tmp/']

ඇත්තෙන්ම ick නික් ඩෙස්ජාර්ඩින්ස් පිළිතුරු දුන්නේ පරිපූර්ණයි. නමුත් අධ්‍යාපනය සඳහා පමණක්: ඔබට අපිරිසිදු ප්‍රවේශයක් භාවිතා කළ හැකිය: ENVතර්කය භාවිතා කිරීම

task :my_task do
  myvar = ENV['myvar']
  puts "myvar: #{myvar}"
end 

rake my_task myvar=10
#=> myvar: 10

desc 'an updated version'
task :task_name, [:arg1, :arg2] => [:dependency1, :dependency2] do |t, args|
    puts args[:arg1]
end

මට අවශ්‍ය වූයේ ධාවනය කිරීමට හැකිවීමයි:

$ rake some:task arg1 arg2

සරලයි නේද? (නෑ!)

රාක් අර්ථ නිරූපණයන් arg1සහ arg2කාර්යයන් ලෙස, ඒවා ක්‍රියාත්මක කිරීමට උත්සාහ කරයි. ඒ නිසා අපි එය කිරීමට පෙර ගබ්සා කරනවා.

namespace :some do
  task task: :environment do
    arg1, arg2 = ARGV

    # your task...

    exit
  end
end

ඒක ගන්න, වරහන්!

වියාචනය : මට අවශ්‍ය වූයේ ඉතා කුඩා සුරතල් ව්‍යාපෘතියක මෙය කිරීමට හැකිවීමයි. පරාවර්තක කාර්යයන් (එනම් rake task1 task2 task3) දාම කිරීමේ හැකියාව ඔබට අහිමි වන බැවින් "සැබෑ ලෝකය" භාවිතය සඳහා අදහස් නොකෙරේ . IMO එය වටින්නේ නැත. කැත භාවිතා කරන්න rake task[arg1,arg2].

රාක් ගොනුවේ මම සාමාන්‍ය රූබි තර්කයක් භාවිතා කරමි:

DB = ARGV[1]

ඉන්පසු මම ගොනුවේ පතුලේ ඇති පරාල කාර්යයන් ඉවත් කරමි (රාක්කය එම තර්කයේ නම මත පදනම් වූ කාර්යයක් සොයනු ඇත).

task :database_name1
task :database_name2

විධාන රේඛාව:

rake mytask db_name

මෙය var = foo ENV var ට වඩා පිරිසිදු බවක් මට දැනෙන අතර කාර්යය [blah, blah2] විසඳුම් වලට තර්ක කරයි.
කඳ කොටස ටිකක් ජෙන්කි, නමුත් ඔබට එකවර පරිසරයක් ඇති පරිසර කිහිපයක් තිබේ නම් එය එතරම් නරක නැත

ඉහත පිළිතුරෙන් තර්කය සම්මත කළ හැකි ක්‍රම නිවැරදි ය. කෙසේ වෙතත්, පරස්පර කර්තව්‍යයන් තර්ක සමඟ ක්‍රියාත්මක කිරීම සඳහා, රේල් පීලි වල නවතම අනුවාදයට සම්බන්ධ කුඩා තාක්ෂණයක් ඇත

එය "නාම අවකාශය: කාර්ය නාමය ['තර්කය 1']" සමඟ ක්‍රියා කරයි.

විධාන රේඛාවෙන් කාර්යය ක්‍රියාත්මක කිරීමේදී ප්‍රතිලෝම උපුටා දැක්වීම් සටහන් කරන්න.

පෙරනිමි කාර්යයට තර්ක යැවීමට, ඔබට මේ වගේ දෙයක් කළ හැකිය. උදාහරණයක් ලෙස, "අනුවාදය" ඔබේ තර්කය යැයි පවසන්න:

task :default, [:version] => [:build]

task :build, :version do |t,args|
  version = args[:version]
  puts version ? "version is #{version}" : "no version passed"
end

එවිට ඔබට එය එසේ හැඳින්විය හැකිය:

$ rake
no version passed

හෝ

$ rake default[3.2.1]
version is 3.2.1

හෝ

$ rake build[3.2.1]
version is 3.2.1

කෙසේ වෙතත්, තර්ක ඉදිරිපත් කිරීමේදී කාර්ය නාමය (පෙරනිමි හෝ ගොඩනැගීම) සඳහන් කිරීමෙන් වැළකී සිටීමට මට ක්‍රමයක් හමු වී නැත. කවුරුහරි ක්‍රමයක් දන්නේ නම් ඇසීමට කැමතියි.

තර්ක විතර්ක සඳහා "විමසුම්" වාක්‍ය ඛණ්ඩයට මම කැමතියි, විශේෂයෙන් සම්මත කළ යුතු තර්ක රාශියක් ඇති විට.

උදාහරණයක්:

rake "mytask[width=10&height=20]"

“විමසුම්” පැවැත්ම:

width=10&height=20

අවවාදයයි: වාක්‍ය ඛණ්ඩය rake "mytask[foo=bar]"සහ නොවන බව සලකන්න rake mytask["foo=bar"]

භාවිතා කරමින් පරාල කාර්යය තුළ විග්‍රහ කරන විට Rack::Utils.parse_nested_query, අපට ලැබෙන්නේ Hash:

=> {"width"=>"10", "height"=>"20"}

(සිසිල් දෙය නම් ඔබට හැෂ් සහ අරා පසුකර යා හැකිය, ඊට වඩා පහතින්)

මෙය සාක්ෂාත් කරගන්නේ කෙසේද:

require 'rack/utils'

task :mytask, :args_expr do |t,args|
  args.with_defaults(:args_expr => "width=10&height=10")
  options = Rack::Utils.parse_nested_query(args[:args_expr])
end

මගේ ප්‍රමාද වූ_ජොබ්_ඇක්ටිව්_රෙකෝඩ්_තෙරඩ් මැණිකේ මම රේල්ස් සමඟ භාවිතා කරන වඩාත් පුළුල් උදාහරණයක් මෙන්න :

bundle exec rake "dj:start[ebooks[workers_number]=16&ebooks[worker_timeout]=60&albums[workers_number]=32&albums[worker_timeout]=120]"

පාරිසරික පරායත්තතාවයකින් (රේල්ස් පරිසරය පැටවීම සඳහා) ඉහත ආකාරයටම විග්‍රහ කර ඇත.

namespace :dj do
  task :start, [ :args_expr ] => :environment do |t, args|
    # defaults here...
    options = Rack::Utils.parse_nested_query(args[:args_expr])  
  end
end

පහත සඳහන් දේ ලබා දෙයි options

=> {"ebooks"=>{"workers_number"=>"16", "worker_timeout"=>"60"}, "albums"=>{"workers_number"=>"32", "worker_timeout"=>"120"}}

ඔබට තර්ක කිරීමේ පිහිටීම කුමක් සඳහාද යන්න මතක තබා ගැනීමට ඔබට කරදර විය නොහැකි නම් සහ ඔබට අවශ්‍ය වන්නේ රූබි තර්ක හැෂ් වැනි දෙයක් කිරීමයි. ඔබට එක් තර්කයක් භාවිතා කර නූලක් පසු කර විකල්පය හැෂ් එකකට යොමු කරන්න.

namespace :dummy_data do
  desc "Tests options hash like arguments"
  task :test, [:options] => :environment do |t, args|
    arg_options = args[:options] || '' # nil catch incase no options are provided
    two_d_array = arg_options.scan(/\W*(\w*): (\w*)\W*/)
    puts two_d_array.to_s + ' # options are regexed into a 2d array'
    string_key_hash = two_d_array.to_h
    puts string_key_hash.to_s + ' # options are in a hash with keys as strings'
    options = two_d_array.map {|p| [p[0].to_sym, p[1]]}.to_h
    puts options.to_s + ' # options are in a hash with symbols'
    default_options = {users: '50', friends: '25', colour: 'red', name: 'tom'}
    options = default_options.merge(options)
    puts options.to_s + ' # default option values are merged into options'
  end
end

විධාන රේඛාවේදී ඔබට ලැබෙනු ඇත.

$ rake dummy_data:test["users: 100 friends: 50 colour: red"]
[["users", "100"], ["friends", "50"], ["colour", "red"]] # options are regexed into a 2d array
{"users"=>"100", "friends"=>"50", "colour"=>"red"} # options are in a hash with keys as strings
{:users=>"100", :friends=>"50", :colour=>"red"} # options are in a hash with symbols
{:users=>"100", :friends=>"50", :colour=>"red", :name=>"tom"} # default option values are merged into options

ඉහත විස්තර කර ඇති බොහෝ ක්‍රම මට වැඩ කළේ නැත, සමහර විට ඒවා නවතම අනුවාද වලින් ඉවත් කර ඇත. යාවත්කාලීන මාර්ගෝපදේශය මෙතැනින් සොයාගත හැකිය: http://guides.rubyonrails.org/command_line.html#custom-rake-tasks

මාර්ගෝපදේශයේ පිටපතක් හා පේස්ට් පිළිතුරු මෙහි ඇත:

task :task_name, [:arg_1] => [:pre_1, :pre_2] do |t, args|
  # You can use args from here
end

මේ ආකාරයට ආයාචනා කරන්න

bin/rake "task_name[value 1]" # entire argument string should be quoted

සාම්ප්‍රදායික තර්ක ශෛලිය සමඟ පරාල කාර්යයන් ක්‍රියාත්මක කිරීම සඳහා:

rake task arg1 arg2

ඉන්පසු භාවිතා කරන්න:

task :task do |_, args|
  puts "This is argument 1: #{args.first}"
end

පහත දැක්වෙන රාක් මැණික් එකතු කරන්න:

Rake::Application.class_eval do

  alias origin_top_level top_level

  def top_level
    @top_level_tasks = [top_level_tasks.join(' ')]
    origin_top_level
  end

  def parse_task_string(string) # :nodoc:
    parts = string.split ' '
    return parts.shift, parts
  end

end

Rake::Task.class_eval do

  def invoke(*args)
    invoke_with_call_chain(args, Rake::InvocationChain::EMPTY)
  end

end

පරාමිතීන් පසු කරන විට, එය වඩා හොඳ විකල්පයක් වන්නේ ආදාන ගොනුවකි, මෙය එක්සෙල් ජේසන් එකක් හෝ ඔබට අවශ්‍ය ඕනෑම දෙයක් විය හැකි අතර එතැන් සිට ඔබට අවශ්‍ය දත්ත ව්‍යුහය සහ විචල්‍යයන් කියවිය යුතුය. ගොනුවක් කියවීමට පහත ව්‍යුහය තිබිය හැකිය.

  namespace :name_sapace_task do
    desc "Description task...."
      task :name_task  => :environment do
        data =  ActiveSupport::JSON.decode(File.read(Rails.root+"public/file.json")) if defined?(data)
    # and work whit yoour data, example is data["user_id"]

    end
  end

උදාහරණ json

{
  "name_task": "I'm a task",
  "user_id": 389,
  "users_assigned": [389,672,524],
  "task_id": 3
}

ක්‍රියාත්මක කිරීම

rake :name_task