Module: HQ::Tools::Getopt

Defined in:
lib/hq/tools/getopt.rb

Class Method Summary collapse

Class Method Details

.process(argv, easy_specs) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/hq/tools/getopt.rb', line 9

def self.process argv, easy_specs

	argv = argv.flatten

	# convert easy_specs into specs
	specs = {}
	ret = {}
	easy_specs.each do |easy_spec|
		if easy_spec[:options]
			options = easy_spec[:options].clone
			options << easy_spec[:default] if easy_spec[:default]
			options.each do |option|
				spec = {}
				spec[:long_name] = to_long option
				spec[:type] = option == easy_spec[:default] ? :switch_default : :switch
				spec[:key] = easy_spec[:name]
				spec[:arg_value] = option
				specs[spec[:long_name]] = spec
			end
			ret[easy_spec[:name]] = easy_spec[:default]
		else
			easy_spec[:long_name] = to_long easy_spec[:name]
			spec = {}
			spec[:long_name] = to_long easy_spec[:name]
			spec[:type] = case
				when easy_spec[:boolean] then :boolean
				when easy_spec[:required] then :required
				else :optional
			end
			spec[:key] = easy_spec[:name]
			spec[:arg_value] = easy_spec[:default]
			spec[:verify] = easy_spec[:regex]
			spec[:convert] = easy_spec[:convert]
			spec[:multi] = easy_spec[:multi]
			specs[spec[:long_name]] = spec
			if easy_spec[:multi]
				ret[easy_spec[:name]] = []
			elsif easy_spec[:boolean]
				ret[easy_spec[:name]] = false
			elsif easy_spec[:required]
				# do nothing
			else
				ret[easy_spec[:name]] = easy_spec[:default]
			end
		end
	end

	# save main argv value because we clobber it
	old_argv = []
	ARGV.each { |arg| old_argv << arg }
	new_argv = []
	argv.each { |arg| new_argv << arg }
	begin

		require "getoptlong"
		getopt_args = []
		specs.each do |long_name, spec|
			getopt_flags = case spec[:type]
				when :required then GetoptLong::REQUIRED_ARGUMENT
				when :optional then GetoptLong::REQUIRED_ARGUMENT
				when :boolean then GetoptLong::NO_ARGUMENT
				when :switch then GetoptLong::NO_ARGUMENT
				when :switch_default then GetoptLong::NO_ARGUMENT
				else raise "Invalid getopt argument type: #{spec[:type]}"
			end
			getopt_args << [ spec[:long_name], getopt_flags ]
			#ret[spec[:key]] = spec[:arg_value] if [ :optional, :switch_default ].include? spec[:type]
			#ret[spec[:key]] = [] if spec[:multi]
			#ret[spec[:key]] = false if spec[:type] == :boolean
		end
		ARGV.clear
		new_argv.each { |arg| ARGV << arg }
		GetoptLong.new(*getopt_args).each do |opt, arg|
			spec = specs[opt]
			case spec[:type]
				when :required, :optional
					ret[spec[:key]] << arg if spec[:multi]
					ret[spec[:key]] = arg unless spec[:multi]
				when :switch, :switch_default
					ret[spec[:key]] = spec[:arg_value]
				when :boolean
					ret[spec[:key]] = true
				else
					raise "Error"
			end
		end

		# check for missing required arguments
		specs.values.each do |spec|
			next unless spec[:type] == :required
			next if ! spec[:multi] && ret.include?(spec[:key])
			next if spec[:multi] && ! ret[spec[:key]].empty?
			msg = "#{$0}: option '#{spec[:long_name]}' is required"
			$stderr.puts msg
			raise GetoptError.new msg
		end

		# check for mismatched regex arguments
		easy_specs.each do |easy_spec|
			next unless easy_spec[:regex]
			if easy_spec[:multi]
				ret[easy_spec[:name]].each do |value|
					next if value =~ /^#{easy_spec[:regex]}$/
					msg = "#{$0}: option '#{easy_spec[:long_name]}' is invalid: #{value}"
					$stderr.puts msg
					raise GetoptError.new msg
				end
			else
				next if ret[easy_spec[:name]] == easy_spec[:default]
				next if ret[easy_spec[:name]] =~ /^#{easy_spec[:regex]}$/
				msg = "#{$0}: option '#{easy_spec[:long_name]}' is invalid: #{ret[easy_spec[:name]]}"
				$stderr.puts msg
				raise GetoptError.new msg
			end
		end

		# perform conversions
		specs.values.each do |spec|
			next unless ret[spec[:key]].is_a? String
			case spec[:convert]
			when nil
				# do nothing
			when Symbol
				ret[spec[:key]] = ret[spec[:key]].send spec[:convert]
			when Method
				ret[spec[:key]] = spec[:convert].call ret[spec[:key]]
			else
				raise "Don't know what to do with #{spec[:convert].class}"
			end
		end

		rest = []
		ARGV.each { |arg| rest << arg }
		return ret, rest

	rescue GetoptLong::MissingArgument
		raise GetoptError

	ensure
		ARGV.clear
		old_argv.each { |arg| ARGV << arg }
	end
end

.to_long(name) ⇒ Object 



5
6
7
 
# File 'lib/hq/tools/getopt.rb', line 5

def self.to_long name
	return "--#{name.to_s.gsub "_", "-"}"
end