Most efficient way to extract arguments from String in Ruby - ruby

Question

I would like to extract some information from a string in Ruby by only reading the String once (O(n) time complexity).
Here is an example:
The string looks like this: -location here -time 7:30pm -activity biking
I have a Ruby object I want to populate with this info. All the keywords are known, and they are all optional.
def ActivityInfo
_attr_reader_ :location, :time, :activity
def initialize(str)
#location, #time, #activity = DEFAULT_LOCATION, DEFAULT_TIME, DEFAULT_ACTIVITY
# Here is how I was planning on implementing this
current_string = ""
next_parameter = nil # A reference to keep track of which parameter the current string is refering to
words = str.split
while !str.empty?
word = str.shift
case word
when "-location"
if !next_parameter.nil?
next_parameter.parameter = current_string # Set the parameter value to the current_string
current_string = ""
else
next_parameter = #location
when "-time"
if !next_parameter.nil?
next_parameter.parameter = current_string
current_string = ""
else
next_parameter = #time
when "-activity"
if !next_parameter.nil?
next_parameter.parameter = current_string
current_string = ""
else
next_parameter = #time
else
if !current_string.empty?
current_string += " "
end
current_string += word
end
end
end
end
So basically I just don't know how to make a variable be the reference of another variable or method, so that I can then set it to a specific value. Or maybe there is just another more efficient way to achieve this?
Thanks!

Answer 1

The string looks suspiciously like a command-line, and there are some good Ruby modules to parse those, such as optparse.
Assuming it's not, here's a quick way to parse the commands in your sample into a hash:
cmd = '-location here -time 7:30pm -activity biking'
Hash[*cmd.scan(/-(\w+) (\S+)/).flatten]
Which results in:
{
"location" => "here",
"time" => "7:30pm",
"activity" => "biking"
}
Expanding it a bit farther:
class ActivityInfo
def initialize(h)
#location = h['location']
#time = h['time' ]
#activity = h['activity']
end
end
act = ActivityInfo.new(Hash[*cmd.scan(/-(\w+) (\S+)/).flatten])
Which sets act to an instance of ActivityInfo looking like:
#<ActivityInfo:0x101142df8
#activity = "biking",
#location = "here",
#time = "7:30pm"
>
--
The OP asked how to deal with situations where the commands are not flagged with - or are multiple words. These are equivalent, but I prefer the first stylistically:
irb(main):003:0> cmd.scan(/-((?:location|time|activity)) \s+ (\S+)/x)
[
[0] [
[0] "location",
[1] "here"
],
[1] [
[0] "time",
[1] "7:30pm"
],
[2] [
[0] "activity",
[1] "biking"
]
]
irb(main):004:0> cmd.scan(/-(location|time|activity) \s+ (\S+)/x)
[
[0] [
[0] "location",
[1] "here"
],
[1] [
[0] "time",
[1] "7:30pm"
],
[2] [
[0] "activity",
[1] "biking"
]
]
If the commands are multiple words, such as "at location":
irb(main):009:0> cmd = '-at location here -time 7:30pm -activity biking'
"-at location here -time 7:30pm -activity biking"
irb(main):010:0>
irb(main):011:0* cmd.scan(/-((?:at \s location|time|activity)) \s+ (\S+)/x)
[
[0] [
[0] "at location",
[1] "here"
],
[1] [
[0] "time",
[1] "7:30pm"
],
[2] [
[0] "activity",
[1] "biking"
]
]
If you need even more flexibility look at Ruby's strscan module. You can use that to tear apart a string and find the commands and their parameters.

Answer 2

Convert String to Options Hash
If you just want easy access to your flags and their values, you can split your string into a hash where each flag is a key. For example:
options = Hash[ str.scan /-(\w+)\s+(\S+)/ ]
=> {"location"=>"here", "time"=>"7:30pm", "activity"=>"biking"}
You can then reference values directly (e.g. options['location']) or iterate through your hash in key/value pairs. For example:
options.each_pair { |k, v| puts "%s %s" % [k, v] }
A Dash of Metaprogramming
Okay, this is serious over-engineering, but I spent a little extra time on this question because I found it interesting. I'm not claiming the following is useful; I'm just saying it was fun for me to do.
If you want to parse your option flags and and dynamically create a set of attribute readers and set some instance variables without having to define each flag or variable separately, you can do this with a dash of metaprogramming.
# Set attribute readers and instance variables dynamically
# using Kernel#instance_eval.
class ActivityInfo
def initialize(str)
options = Hash[ str.scan /-(\w+)\s+(\S+)/ ]
options.each_pair do |k, v|
self.class.instance_eval { attr_reader k.to_sym }
instance_variable_set("##{k}", v)
end
end
end
ActivityInfo.new '-location here -time 7:30pm -activity biking'
=> #<ActivityInfo:0x00000001b49398
#activity="biking",
#location="here",
#time="7:30pm">
Honestly, I think setting your variables explicitly from an options hash such as:
#activity = options['activity']`
will convey your intent more clearly (and be more readable), but it's always good to have alternatives. Your mileage may vary.

Answer 3

Why reinvent the wheel when Thor can do the heavy lifting for you?
class ActivityInfo < Thor
desc "record", "record details of your activity"
method_option :location, :type => :string, :aliases => "-l", :required => true
method_option :time, :type => :datetime, :aliases => "-t", :required => true
method_option :activity, :type => :string, :aliases => "-a", :required => true
def record
location = options[:location]
time = options[:time]
activity = options[:activity]
# record details of the activity
end
end
The options will be parse for you based on the datatype you specified. You can invoke it programmatically:
task = ActivityInfo.new([], {location: 'NYC', time: Time.now, activity: 'Chilling out'})
task.record
Or from command line: thor activity_info:record -l NYC -t "2012-06-23 02:30:00" -a "Chilling out"