shell_helpers 0.1.0 → 0.6.0

data/lib/shell_helpers/run.rb

@@ -2,35 +2,94 @@
 require 'open3'
 require 'shellwords'
 
-module SH
+module ShellHelpers
 	module Run #{{{
 		extend(self)
+		RunError=Class.new(StandardError)
+
+		def sudo_args(sudoarg)
+			return "" unless sudoarg
+			return sudoarg.shellsplit if sudoarg.is_a?(String)
+			["sudo"]
+		end
+
 		#the run_* commands here capture all the output
 		def run_command(*command)
+			#stdout, stderr, status
 			return Open3.capture3(*command)
 		end
 
-		def run_output(*command)
-			stdout,_stderr,_status = run_command(*command)
+		#Only capture output
+		def output_of(*command)
+			stdout,status = Open3.capture2(*command)
+			yield stdout, status if block_given?
 			return stdout
 		end
 
-		def run_status(*command)
-			_stdout,_stderr,status = run_command(*command)
+		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
 
-		#a simple wrapper for %x//
-		def run_simple(*command, quiet: false, fail_mode: :error, chomp: false)
-			if command.length > 1
-				launch=command.shelljoin
+		#wrap the output of the command in an enumerator
+		#allows to lazily parse the result
+		def run_lazy(*command)
+			r=nil
+			IO.popen(command) do |f|
+				r=f.each_line.lazy
+			end
+			r
+		end
+
+		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 {|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
+
+		#by default capture stdout and status
+		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, **opts)
+
+			if args.length > 1
+				launch=args.shelljoin
 			else
-				launch=command.first
+				launch=args.first #assume it has already been escaped
 			end
-			launch+=" 2>/dev/null" if quiet
+			launch+=" 2>/dev/null" if error==:quiet or quiet
+			launch+=" >/dev/null" if output==:quiet
+			out=error=nil
+
 			begin
-				out = %x/#{launch}/
-				status=$?.success?
+				if error==:capture
+					out, error, 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
@@ -38,24 +97,49 @@ module SH
 					raise e
 				when :empty
 					out=""
+				when :nil
+					out=nil
+				when Proc
+					fail_mode.call(e)
 				end
 			end
-			out.chomp! if chomp
-			return out, status
-		end
-
-		#capture stdout and status, silence stderr
-		def run(*args)
-			begin
-				if Open3.respond_to?(:capture3) then
-					out, _error, status=Open3.capture3(*args)
-					return out, status.success?
+			status=ProcessStatus.new(status, expected) if expected
+			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, error)
+				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 = `#{args.shelljoin} 2>/dev/null`
-					status=$?
-					return out, status.success?
+					out.chomp! 
 				end
 			end
+
+			return out, error, status if error
+			return out, status
+		end
+
+		#a simple wrapper for %x//
+		def run_simple(*command, **opts, &b)
+			# here the block is called in case of failure
+			opts[:error_mode]=b if b
+			out, *_rest = run(*command, **opts)
+			return out
 		end
 
 		#same as Run, but if we get interrupted once, we don't want to launch any more commands
@@ -65,7 +149,7 @@ module SH
 			def run_command(*args)
 				if !@interrupted
 					begin
-						DR::Run.run_command(*args)
+						Run.run_command(*args)
 					rescue Interrupt #interruption
 						@interrupted=true
 						return "", "", false
@@ -75,10 +159,12 @@ module SH
 				end
 			end
 
+			#TODO: handle non default options, 'error: :capture' would imply we
+			#need to return "", "", false
 			def run(*command)
 				if !@interrupted
 					begin
-						return DR::Run.run(*args)
+						return Run.run(*command)
 					rescue Interrupt #interruption
 						@interrupted=true
 						return "", false
@@ -126,7 +212,7 @@ module SH
 							 else
 								 status
 							 end
-			if status.kind_of? Fixnum
+			if status.kind_of? Integer
 				status
 			elsif status
 				0

data/lib/shell_helpers/sh.rb

@@ -1,14 +1,25 @@
 # vim: foldmethod=marker
-#from methadone (error.rb, exit_now.rb, process_status.rb, run.rb; last
-#import v1.3.1-2-g9be3b5a)
-require_relative 'logger'
-require_relative 'run'
-require 'simplecolor'
+#from methadone (error.rb, exit_now.rb, process_status.rb, run.rb;
+#last import 4626a2bca9b6e54077a06a0f8e11a04fadc6e7ae, 2017-01-19
+require 'shell_helpers/logger'
+require 'shell_helpers/run'
+require 'forwardable'
 
-module SH
+begin
+	require 'simplecolor'
+rescue LoadError
+	#fallback, don't colorize
+	module SimpleColor
+		def self.color(s,**opts)
+			puts s
+		end
+	end
+end
+
+module ShellHelpers
 	# ExitNow {{{
 	# Standard exception you can throw to exit with a given status code.
-	# Generally, you should prefer DR::ExitNow.exit_now! over using this
+	# Generally, you should prefer SH::ExitNow.exit_now! over using this
 	# directly, however you may wish to create a rich hierarchy of exceptions
 	# that extend from this in your app, so this is provided if you wish to
 	# do so.
@@ -102,10 +113,50 @@ module SH
 		extend self
 		attr_writer :default_sh_options
 		def default_sh_options
-			@default_sh_options||={log: false, capture: false, on_success: nil, on_failure: nil, expected:0, dryrun: false, escape: false,
-			log_level_execute: :debug, log_level_error: :error,
+			@default_sh_options||={log: true, capture: false, on_success: nil, on_failure: nil, expected:0, dryrun: false, escape: false,
+			log_level_execute_debug: :debug,
+			log_level_execute: :info, log_level_error: :error,
 			log_level_stderr: :error, log_level_stdout_success: :info,
-			log_level_stdout_fail: :warn}
+			log_level_stdout_fail: :warn, detach: false}
+		end
+
+		attr_writer :spawned
+		def spawned
+			@spawned||=[]
+		end
+		def wait_spawned
+			spawned.each {|c| Process.waitpid(c)}
+		end
+
+		# callback called by sh to select the exec mode
+		# mode: :system,:spawn,:exec,:capture
+		# opts: sudo, env
+		def shrun(*args,mode: :system, **opts)
+			env, args, spawn_opts=Run.process_command(*args, **opts)
+			# p env, args, spawn_opts
+			case mode
+			when :system
+				system(env,*args,spawn_opts)
+			when :spawn, :detach
+				pid=spawn(env,*args,spawn_opts)
+				if mode==:detach
+					Process.detach(pid) 
+				else
+					spawned << pid
+					if block_given?
+						yield pid
+						Process.wait(pid)
+					else
+						pid
+					end
+				end
+			when :exec
+				exec(env,*args,spawn_opts)
+			when :capture
+				Run.run_command(env,*args,spawn_opts)
+			when :run
+				Run.run(env,*args,spawn_opts)
+			end
 		end
 
 		# Run a shell command, capturing and logging its output.
@@ -117,7 +168,7 @@ module SH
 		#			name: pretty name of command
 		#			on_success,on_failure: blocks to call on success/failure
 		# block:: if provided, will be called if the command exited nonzero.	The block may take 0, 1, 2, or 3 arguments.
-		#					The arguments provided are the standard output as a string, standard error as a string, and the processstatus as DR::ProcessStatus
+		#					The arguments provided are the standard output as a string, standard error as a string, and the processstatus as SH::ProcessStatus
 		#					You should be safe to pass in a lambda instead of a block, as long as your lambda doesn't take more than three arguments
 		#
 		# Example
@@ -130,41 +181,48 @@ module SH
 		#			end
 		#
 		# Returns the exit status of the command.  Note that if the command doesn't exist, this returns 127.
+
 		def sh(*command, **opts, &block)
 			defaults=default_sh_options
 			curopts=defaults.dup
 			defaults.keys.each do |k|
 				v=opts.delete(k)
-				curopts[k]=v if v
+				curopts[k]=v unless v.nil?
 			end
+
 			log=curopts[:log]
-			command=command.first if command.length==1 and command.first.kind_of?(Array)
-			command_name = curopts[:name] || command_name(command)
+			# command=command.first if command.length==1 and command.first.kind_of?(Array) #so that sh(["ls", "-a"]) works
+			command_name = curopts[:name] || command_name(command) #this keep the options
 			command=command.shelljoin if curopts[:escape]
-			sh_logger.send(curopts[:log_level_execute], SimpleColor.color("Executing '#{command_name}'",:bold)) if log
+			if log
+				sh_logger.send(curopts[:log_level_execute], SimpleColor.color("Executing '#{command_name}'",:bold))
+				p_env, p_args, p_opts= Run.process_command(*command, **opts)
+				sh_logger.send(curopts[:log_level_execute_debug], SimpleColor.color("Debug execute: '#{[p_env, *p_args, p_opts]}'", :bold))
+			end
 
 			if !curopts[:dryrun]
-				if curopts[:capture]
-					case command
-					when Array
-						stdout,stderr,status = DR::Run.run_command(*command,**opts)
-					else
-						stdout,stderr,status = DR::Run.run_command(command.to_s,**opts)
+				if curopts[:capture] || curopts[:mode]==:capture
+					stdout,stderr,status = shrun(*command,**opts,mode: :capture)
+				elsif curopts[:detach] || curopts[:mode]==:spawn || curopts[:mode]==:detach
+					mode = curopts[:detach] ? :detach : curops[:mode]
+					_pid = shrun(*command,**opts, mode: mode)
+					status=0; stdout=nil; stderr=nil
+				elsif curopts[:mode]==:run
+					*res=shrun(*command,**opts,mode: :capture)
+					case res.length
+					when 2
+						stdout, status=res; stderr=nil
+					when 3
+						stdout, stderr, status=res
 					end
 				else
-					case command
-					when Array
-						system(*command,**opts)
-					else
-						system(command.to_s,**opts)
-					end
-					status=$?
-					stdout=nil; stderr=nil
+					mode=curopts[:mode]||:system
+					shrun(*command,mode: mode, **opts)
+					status=$?; stdout=nil; stderr=nil
 				end
 			else
-				puts command.to_s
-				status=0
-				stdout=nil; stderr=nil
+				sh_logger.info command.to_s
+				status=0; stdout=nil; stderr=nil
 			end
 			process_status = ProcessStatus.new(status,curopts[:expected])
 
@@ -187,7 +245,7 @@ module SH
 
 		# Run a command, throwing an exception if the command exited nonzero.
 		# Otherwise, behaves exactly like #sh.
-		# Raises DR::FailedCommandError if the command exited nonzero.
+		# Raises SH::FailedCommandError if the command exited nonzero.
 		# Examples:
 		#
 		#			sh!("rsync foo bar")
@@ -197,7 +255,7 @@ module SH
 		def sh!(*args,failure_msg: nil,**opts, &block)
 			on_failure=Proc.new do |*blockargs|
 				process_status=blockargs.last
-				raise DR::FailedCommandError.new(process_status.exitstatus,command_name(args),failure_msg: failure_msg)
+				raise FailedCommandError.new(process_status.exitstatus,command_name(args),failure_msg: failure_msg)
 			end
 			sh(*args,**opts,on_failure: on_failure,&block)
 		end
@@ -212,18 +270,27 @@ module SH
 			@sh_logger = logger
 		end
 
+		#split commands on newlines and run sh on each line
+		def sh_commands(com, **opts)
+			com.each_line do |line|
+				sh(line.chomp,**opts)
+			end
+		end
+
 	private
 		def command_name(command)
 			if command.size == 1
-				return command.first.to_s
+				command.first.to_s
 			else
-				return command.to_s
+				#command.to_s
+				#command.map {|i| i.to_s}.to_s
+				command.shelljoin
 			end
 		end
 
 		def sh_logger
 			@sh_logger ||= begin
-				raise StandardError, "No logger set! Please include DR::CLILogging
+				raise StandardError, "No logger set! Please include SH::CLILogging
 ng or provide your own via #change_sh_logger." unless self.respond_to?(:logger)
 				self.logger
 			end
@@ -231,8 +298,8 @@ ng or provide your own via #change_sh_logger." unless self.respond_to?(:logger)
 
 	end
 
-	#SH::ShLog.sh is like SH::Sh.sh but with login enabled even when
-	#command succeed
+	#SH::ShLog.sh is by default like SH::Sh.sh.
+	# It is easy to change it to be more verbose though
 	module ShLog
 		include Sh
 		extend self
@@ -240,5 +307,87 @@ ng or provide your own via #change_sh_logger." unless self.respond_to?(:logger)
 		@default_sh_options[:log]=true
 		@default_sh_options[:log_level_execute]=:info
 	end
+
+	# Do not log execution
+	module ShQuiet
+		include Sh
+		extend self
+		@default_sh_options=default_sh_options
+		@default_sh_options[:log]=true
+		@default_sh_options[:log_level_execute]=:debug
+	end
+
+	# Completely silent
+	module ShSilent
+		include Sh
+		extend self
+		@default_sh_options=default_sh_options
+		@default_sh_options[:log]=false
+	end
+
+	module ShDryRun
+		include Sh
+		extend self
+		@default_sh_options=default_sh_options
+		@default_sh_options[:log]=true
+		@default_sh_options[:log_level_execute]=:info
+		@default_sh_options[:dryrun]=true
+	end
+
+	# this modules deal with default options, paths and arg handling for
+	# different programs, while letting the user control
+	# Exemples:
+	# ShConfig.launch(:ls, "/", config: {ls: {default_opts: ["-l"]}})
+	# => ["ls", "-l", "/", {}]
+	# ShConfig.launch(:ls, "/", config: {ls: {default_opts: ["-l"]}}, method: :sh)
+	# ShConfig.launch(:ls, "/", config: {ls: {default_opts: ["-l"]}}) { |*args| SH.sh(*args) }
+	# ShConfig.launch(:ls, "/", config: {ls: {wrap: ->(cmd,*args, &b) { b.call(cmd, '-l', *args) } }}, method: :sh)
+
+	module ShConfig
+		extend self
+		def launch(*args, opts: [], cmd_prepend: [], cmd_postpone: [], config: self.sh_config, default_opts: true, method: nil, **keywords, &b)
+			if args.length == 1 and (arg=args.first).is_a?(String)
+				args=arg.shellsplit
+				args[0]=args[0][1..-1].to_sym if args[0][0]==':'
+			end
+			opts=opts.shellsplit if opts.is_a?(String)
+			default_opts=default_opts.shellsplit if default_opts.is_a?(String)
+			cmd_prepend=cmd_prepend.shellsplit if cmd_prepend.is_a?(String)
+			cmd_postpone=cmd_postpone.shellsplit if cmd_postpone.is_a?(String)
+			dopts = default_opts.is_a?(Array) ? default_opts : []
+			cmd, *args=args
+			if cmd.is_a?(Symbol)
+				if config.key?(cmd)
+					c=config[cmd]
+					cmd=c[:bin] || cmd.to_s
+					dopts += (Array(c[:default_opts])||[]) if default_opts
+					wrap=c[:wrap]
+				else
+					cmd=cmd.to_s
+				end
+			end
+			cargs=Array(cmd_prepend) + [cmd] + dopts + Array(opts) + args + Array(cmd_postpone)
+			if !b
+				if method
+					b=lambda do |*args|
+						SH.public_send(method, *args)
+					end
+				else
+					b=lambda do |*args|
+						return *args
+					end
+				end
+			end
+			if wrap
+				wrap.call(*cargs, **keywords, &b)
+			else
+				b.call(*cargs, **keywords)
+			end
+		end
+
+		def sh_config
+			{}
+		end
+	end
 	# }}}
 end