Ruby脚本从特定的行或方法开始

Question

Let's say i have a script:

!#usr/bin/ruby

# step 1
puts "That's first"
# some code

#step 2
puts "That's second"
# some code

Is there a way to pass ARGV to script that will start execution from a specific line (or step, or class, or whatever)? For example executing $ ruby script.rb -s 2 will start from second step.

I have a thought about parsing the argument with if\\else , but in this case script will become much more complicated and not DRY at all.

Any ideas?

Answer 1

Here's a program run_from_line.rb which accepts three arguments: path and start line, and end line. End line is optional and defaults to -1.

#/usr/bin/env ruby

path = ARGV.shift
program_text = File.readlines(path)
start_line = ARGV.shift.to_i;
end_line = ARGV.shift || '-1'
end_line = end_line.to_i

selected_code = program_text[start_line..end_line].join
eval selected_code

With this script at test.rb :

puts "line 0"
puts "line 1"
puts "line 2"

Testing:

> ruby run_from_line.rb test.rb 1
line 1
line 2

> ruby run_from_line.rb test.rb 1 1
line 1

If you want to make this a system-wide script, run chmod a+x run_from_line.rb then sudo mv run_from_line.rb /usr/local/sbin

Answer 2

Bad things happen when you use GOTO.

Here's a proposal that could solve your problem in a bit more elegant way :

Define your steps in 'define_steps.rb' :

# define_steps.rb
#####################################################
@steps = []

def step(i, &block)
  @steps[i] = block
end

def launch_steps!(min = 0, max = @steps.size - 1)
  @steps[min..max].each.with_index(min) do |block, i|
    if block
      puts "Launching step #{i}"
      block.call
    end
  end
end
#####################################################

step 1 do
  puts 'Step 1 with lots of code'
end

step 2 do
  puts 'Step 2 with lots of code'
end

step 3 do
  puts 'Step 3 with lots of code'
end

step 4 do
  puts 'Step 4 with lots of code'
end

Launch them separately with launch_steps.rb :

# launch_steps.rb
require_relative 'define_steps'

launch_steps!
puts "-----------------"
launch_steps!(2,3)

It outputs :

Launching step 1
Step 1 with lots of code
Launching step 2
Step 2 with lots of code
Launching step 3
Step 3 with lots of code
Launching step 4
Step 4 with lots of code
-----------------
Launching step 2
Step 2 with lots of code
Launching step 3
Step 3 with lots of code

launch_steps! without parameters runs every defined step, launch_steps!(min,max) runs every step between min and max , launch_steps!(min) runs step min and every step after.

Answer 3

There are ways as the answer of max shows you, but you shouldn't do it. There were questions about a goto statement for Ruby before you know. Why should you go back to the techniques used in BASIC ? Show us a usage and we'll show you better ways.

If you are begining with Ruby and programming you can just use a procedural way of programming like

def print_a
  puts "a"
end

and later on, no matter where the line of "puts a" has moved to in between you last update

print_a

If you are more experienced you'll use this with a combination of Object Oriented or Functional way of programming.

One acceptional use comes me in to mind: conditional require 's or load's

if condition
  require ./mycode_only_to be_executed_in_this_case.rb'
end

Hope I got you rethinking your question..

EDIT after comment op

The example you refer to isn't DRY, that is the first thing that I' m noticing. See https://en.wikipedia.org/wiki/Don 't_repeat_yourself for a definition of DRY

Here what I would make of it, I still use a methods to envelop my code so that it is code that I can reuse and has only one purpose and is testable: connect to a site. No duplicate code, so DRY.

require 'watir'

def goto_site site
  a = Watir::Browser.new :chrome
  a.goto site
  # a lot of code down here
  a.close
end

goto_site 'site.com'