Module: ShellHelpers::Run

Extended by:
Run
Included in:
ShellHelpers, Run
Defined in:
lib/shell_helpers/run.rb

Overview

{{{

Defined Under Namespace

Modules: Interrupt

Constant Summary collapse

RunError = 
Class.new(StandardError)

Instance Method Summary collapse

Instance Method Details

#output_of(*command) {|stdout, status| ... } ⇒ Object

Only capture output

Yields:

  • (stdout, status) 


19
20
21
22
23
 
# File 'lib/shell_helpers/run.rb', line 19

def output_of(*command)
	stdout,status = Open3.capture2(*command)
	yield stdout, status if block_given?
	return stdout
end

#process_command(*args, **opts) ⇒ Object

get the args, environment and spawning options



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/shell_helpers/run.rb', line 56

def process_command(*args, **opts)
	spawn_opts={}
	if args.last.kind_of?(Hash)
		#we may have no symbol keywords
		*args,spawn_opts=*args
	end
	sudo=opts.delete(:sudo)
	env={}
	if args.first.kind_of?(Hash)
		env,*args=*args
	end
	env.merge!(opts.delete(:env)||{})
	args=args.map.with_index {|arg, i| i == 0 && arg.is_a?(Array) ? arg : arg.to_s} if args.length > 1
	spawn_opts.merge!(opts)
	if sudo
		if args.length > 1
			args.unshift(*Run.sudo_args(sudo)) 
		else
			args="#{Run.sudo_args(sudo).shelljoin} #{args.first}"
		end
	end
	return env, args, spawn_opts
end

#run(*args, output: :capture, error: nil, fail_mode: :error, chomp: false, sudo: false, error_mode: nil, expected: nil, on_success: nil, quiet: nil, **opts) {|status_success, out, err, status| ... } ⇒ Object

Run a command by default capture stdout and status callbacks: yield status.success?, out, err, status if block_given? if status.success? => on_success.call(status, out, err) else error_mode.call(status, out, error) rescue ... => fail_mode.call(e) return status, out, error

Yields:

  • (status_success, out, err, status) 


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
152
153
154
155
 
# File 'lib/shell_helpers/run.rb', line 87

def run(*args, output: :capture, error: nil, fail_mode: :error, chomp: false, sudo: false, error_mode: nil, expected: nil, on_success: nil, quiet: nil, **opts)
	env, args, spawn_opts=Run.process_command(*args, sudo: sudo, **opts)

	if args.is_a?(Array)
		if args.length > 1
			launch=args.shelljoin
		else
			launch=args.first #assume it has already been escaped
		end
	else
		launch=args.to_s
	end
	launch+=" 2>/dev/null" if error==:quiet or quiet
	launch+=" >/dev/null" if output==:quiet
	out=err=nil

	begin
		if error==:capture
			out, err, status=Open3.capture3(env, launch, spawn_opts)
		elsif output==:capture
			out, status=Open3.capture2(env, launch, spawn_opts)
		else
			system(env, launch, spawn_opts)
			status=$?
		end
	rescue => e
		status=false
		case fail_mode
		when :error
			raise e
		when :empty
			out=""
		when :nil
			out=nil
		when Proc
			fail_mode.call(e)
		end
	end
	status=ProcessStatus.new(status, expected) if expected
	status_success=status.success? if status.respond_to? :success?
	yield status_success, out, err, status if block_given?
	if status_success
		# this block is called in case of success
		on_success.call(status, out, err) if on_success.is_a?(Proc)
	else # the command failed
		case error_mode
		when :nil
			out=nil
		when :empty
			out=""
		when :error
			raise RunError.new("Error running command '#{launch}': #{status}")
		when Proc
			error_mode.call(status, out, err)
		end
	end
	if chomp and out
		case chomp
		when :line, :lines
			#out is now an array
			out=out.each_line.map {|l| l.chomp}
		else
			out.chomp! 
		end
	end

	# return out, error, status if error
	return status, out, err
end

#run_command(*command) ⇒ Object

the run_* commands here capture all the output



13
14
15
16
 
# File 'lib/shell_helpers/run.rb', line 13

def run_command(*command)
	#stdout, stderr, status
	return Open3.capture3(*command)
end

#run_lazy(*command) ⇒ Object

wrap the output of the command in an enumerator allows to lazily parse the result



35
36
37
38
39
40
41
 
# File 'lib/shell_helpers/run.rb', line 35

def run_lazy(*command)
	r=nil
	IO.popen(command) do |f|
		r=f.each_line.lazy
	end
	r
end

#run_simple(*command, **opts, &b) ⇒ Object

a simple wrapper for %x// return the output; the block is called in case of an error eg SH.run_simple("echo foo; false") do p "error" end => returns "foo\n" and prints error



161
162
163
164
165
166
 
# File 'lib/shell_helpers/run.rb', line 161

def run_simple(*command, **opts, &b)
	# here the block is called in case of error
	opts[:error_mode]=b if b
	_status, out, _error = run(*command, **opts)
	return out
end

#run_success(*command, **opts, &b) ⇒ Object

like run, but only returns status.success?



169
170
171
172
 
# File 'lib/shell_helpers/run.rb', line 169

def run_success(*command, **opts, &b)
	status, _out, _error = run(*command, **opts, &b)
	status.success?
end

#status_of(*command) {|stdout, stderr, status| ... } ⇒ Object

Yields:

  • (stdout, stderr, status) 


25
26
27
28
29
30
31
 
# File 'lib/shell_helpers/run.rb', line 25

def status_of(*command)
	stdout,stderr,status = run_command(*command)
	yield stdout, stderr, status if block_given?
	return status.success?
	#system(*command)
	#return $?.dup
end

#sudo_args(sudoarg) ⇒ Object

Launching a command handle sudo arguments



46
47
48
49
50
51
52
53
 
# File 'lib/shell_helpers/run.rb', line 46

def sudo_args(sudoarg)
	if sudoarg.respond_to?(:sudo_loop)
		sudoarg.sudo_loop
	end
	return [] unless sudoarg
	return sudoarg.shellsplit if sudoarg.is_a?(String)
	["sudo"]
end