shell_helpers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e423354674b7162de244672ab417617837d4667f
+  data.tar.gz: 36527735c314d40be7389de683688e4446c24961
+SHA512:
+  metadata.gz: 743a7bbaec3fa0511cbba321b847db43233a3c964bc4a03cbd07577c5ef2ae4e5357d98a9906532c5536842f92f10ecddf815904f2e776035533763a3a9b8fb4
+  data.tar.gz: 023a3e4ce0a45b3cde0c94906ae05ab1d15687531f9425eb93b60fd59d1fd17c3fd6939b629617d92f0520d6083f06b729a3e54e1ae2f3a317ce58c6b80bf03f

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,2 @@
+doc/
+pkg/

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown -M kramdown --title "shell_helpers Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2015-02-24
+
+* Initial release:
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Damien Robert
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# shell_helpers
+
+* [Homepage](https://github.com/DamienRobert/shell_helpers#readme)
+* [Gems]("https://rubygems.org/gems/shell_helpers)
+* [Issues](https://github.com/DamienRobert/shell_helpers/issues)
+* [Documentation](http://rubydoc.info/gems/shell_helpers/frames)
+* [Email](mailto:Damien.Olivier.Robert+gems at gmail.com)
+
+## Description
+
+  This gem contains a collection of libraries to ease working with the
+  shell with ruby.
+
+  A lot of the ideas here are inspired by the utilities in
+  [methadone](https://github.com/davetron5000/methadone). In particular
+  `logger.rb` and `sh.rb` which were based on `cli_logger.rb`,
+  `cli_logging.rb`, `error.rb`, `exit_now.rb`, `process_status.rb`,
+  `run.rb` from methadone.
+
+  The reason to incorporate them in this gem is that I wanted to be able to
+  add some functionalities (such as `log_and_do` for `logger.rb`, and on
+  succes and on error callbacks for `sh.rb`), and also to be able to use
+  this functionality from other command parsers than methadone
+  (like [gli](https://github.com/davetron5000/gli)).
+
+## Install
+
+    $ gem install shell_helpers
+
+## Copyright
+
+Copyright (c) 2015 Damien Robert
+
+MIT License. See {file:LICENSE.txt} for details.
+
+See above for the copyright: for the files `logger.rb` and `sh.rb` the
+copyright applies only to the diff from the original import from methadone.

data/Rakefile

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard

data/gemspec.yml

@@ -0,0 +1,15 @@
+name: shell_helpers
+summary: "Shell Helpers"
+description: |
+  Collection of script to ease working with the shell with ruby.
+license: MIT
+authors: Damien Robert
+email: Damien.Olivier.Robert+gems@gmail.com
+homepage: https://github.com/DamienRobert/shell_helpers#readme
+
+dependencies:
+  drain: ~> 0.1
+development_dependencies:
+  minitest: ~> 5.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/lib/shell_helpers.rb

@@ -0,0 +1,32 @@
+require 'shell_helpers/version'
+
+require 'shellwords'; require 'pathname'; require 'fileutils'
+require 'dr/ruby_ext/core_ext'; require 'dr/ruby_ext/pathname_ext'
+#load everything in shell_helpers/*.rb
+dir=File.expand_path(File.basename(__FILE__).chomp('.rb'), File.dirname(__FILE__))
+Dir.glob(File.expand_path('*.rb',dir)) do |file|
+	require file
+end
+
+module SH
+	include Run #run_command, run_output, run_status, run
+	include CLILogging #logger.{debug info warn error fatal}, log_and_do
+	include ExitNow #exit_now!
+	include Sh #sh, sh!
+	include ShellExport #export
+	include ShellUtils #find, run_pager
+	extend self
+	#activates debug mode
+	def self.debug(level=Logger::DEBUG)
+		#activates logging on Pathname
+		Pathname.send(:include, CLILogging)
+		logger.level=(level)
+	end
+	#including SH::FU to add FileUtils
+	module FU
+		include ::FileUtils
+		include ::SH
+		extend self
+	end
+end
+

data/lib/shell_helpers/logger.rb

@@ -0,0 +1,219 @@
+# vim: foldmethod=marker
+#From methadone (cli_logger.rb, cli_logging.rb, last import: v1.3.1-2-g9be3b5a)
+require 'logger'
+
+module SH
+	# CLILogger {{{
+	# A Logger instance that gives better control of messaging the user and
+	# logging app activity.  At it's most basic, you would use <tt>info</tt>
+	# as a replacement for +puts+ and <tt>error</tt> as a replacement for
+	# <tt>STDERR.puts</tt>.  Since this is a logger, however, you can also
+	# use #debug, #warn, and #fatal, and you can control the format and
+	# "logging level" as such.
+	#
+	# So, by default:
+	# * debug messages do not appear anywhere
+	# * info messages appear on the standard output
+	# * warn, error, and fatal message appear on the standard error
+	# * The default format of messages is simply the message, no logging
+	# cruft, however if your output is redirected to a file, a better
+	# timestamped logging format is used
+	#
+	# You can customize this in several ways:
+	# * You can override the devices used by passing different devices to the constructor
+	# * You can adjust the level of message that goes to the error logger via error_level=
+	# * You can adjust the format for messages to the error logger separately via error_formatter=
+	#
+	# === Example
+	#
+	#			logger = CLILogger.new
+	#			logger.debug("Starting up") # => only the standard output gets this
+	#			logger.warn("careful!") # => only the standard error gets this
+	#			logger.error("Something went wrong!") # => only the standard error gets this
+	#
+	#			logger = CLILogger.new
+	#			logger.error_level = Logger::ERROR
+	#			logger.debug("Starting up") # => only the standard output gets this
+	#			logger.warn("careful!") # => only the standard OUTPUT gets this
+	#			logger.error("Something went wrong!") # => only the standard error gets this
+	#
+	#			logger = CLILogger.new('logfile.txt')
+	#			logger.debug("Starting up") #=> logfile.txt gets this
+	#			logger.error("Something went wrong!") # => BOTH logfile.txt AND the standard error get this
+	class CLILogger < Logger
+		BLANK_FORMAT = lambda { |severity,datetime,progname,msg|
+			msg + "\n"
+		}
+
+		# Helper to proxy methods to the super class AND to the internal error logger
+		# +symbol+:: Symbol for name of the method to proxy
+		def self.proxy_method(symbol) #:nodoc:
+			old_name = "old_#{symbol}".to_sym
+			alias_method old_name,symbol
+			define_method symbol do |*args,&block|
+				send(old_name,*args,&block)
+				@stderr_logger.send(symbol,*args,&block)
+			end
+		end
+
+		proxy_method :'formatter='
+		proxy_method :'datetime_format='
+
+		def add(severity, message = nil, progname = nil, &block) #:nodoc:
+			if @split_logs
+				unless severity >= @stderr_logger.level
+					super(severity,message,progname,&block)
+				end
+			else
+				super(severity,message,progname,&block)
+			end
+			@stderr_logger.add(severity,message,progname,&block)
+		end
+
+		DEFAULT_ERROR_LEVEL = Logger::Severity::WARN
+
+		# A logger that logs error-type messages to a second device; useful for
+		# ensuring that error messages go to standard error.	This should be
+		# pretty smart about doing the right thing.  If both log devices are
+		# ttys, e.g. one is going to standard error and the other to the
+		# standard output, messages only appear once in the overall output
+		# stream.  In other words, an ERROR logged will show up *only* in the
+		# standard error.  If either log device is NOT a tty, then all messages
+		# go to +log_device+ and only errors go to +error_device+
+		#
+		# +log_device+:: device where all log messages should go, based on level
+		# By default, this is Logger::Severity::WARN
+		# +error_device+:: device where all error messages should go.
+		def initialize(log_device=$stdout,error_device=$stderr,
+									 split_log:log_device.tty? && error_device.tty?)
+			super(log_device)
+			@stderr_logger = Logger.new(error_device)
+
+			@split_logs = split_log
+			self.level = Logger::Severity::INFO
+			@stderr_logger.level = DEFAULT_ERROR_LEVEL
+
+			self.formatter = BLANK_FORMAT if log_device.tty?
+			@stderr_logger.formatter = BLANK_FORMAT if error_device.tty?
+		end
+
+		def level=(level)
+			super(level)
+			#current_error_level = @stderr_logger.level
+			if (level > DEFAULT_ERROR_LEVEL) && @split_logs
+				@stderr_logger.level = level
+			end
+		end
+
+		# Set the threshold for what messages go to the error device.  Note
+		# that calling #level= will *not* affect the error logger *unless* both
+		# devices are TTYs.
+		# +level+:: a constant from Logger::Severity for the level of messages that should go to the error logger
+		def error_level=(level)
+			@stderr_logger.level = level
+		end
+
+		# Overrides the formatter for the error logger.  A future call to
+		# #formatter= will affect both, so the order of the calls matters.
+		# +formatter+:: Proc that handles the formatting, the same as for #formatter=
+		def error_formatter=(formatter)
+			@stderr_logger.formatter=formatter
+		end
+
+	end
+	#}}}
+	# CLILogging {{{
+	# Provides easier access to a shared DR::CLILogger instance.
+	# Include this module into your class, and #logger provides access to a
+	# shared logger. This is handy if you want all of your clases to have
+	# access to the same logger, but don't want to (or aren't able to) pass
+	# it around to each class.
+	# This also provides methods for direct logging without going through the
+	# #logger
+	#
+	# === Example
+	#
+	#			class MyClass
+	#				include DR::CLILogging
+	#
+	#				def doit
+	#					debug("About to doit!")
+	#					if results
+	#						info("We did it!")
+	#					else
+	#						error("Something went wrong")
+	#					end
+	#					debug("Done doing it")
+	#				end
+	#			end
+	#
+	# Note that every class that mixes this in shares the *same logger
+	# instance*, so if you call #change_logger, this will change the logger
+	# for all classes that mix this in.  This is likely what you want.
+	module CLILogging
+		extend self
+
+		# Access the shared logger.  All classes that include this module
+		# will get the same logger via this method.
+		def logger
+			unless Module.class_variable_defined?(:@@logger)
+				@@logger = CLILogger.new
+				@@logger.progname=$0
+			end
+			@@logger
+		end
+
+		# Change the global logger that includers will use.  Useful if you
+		# don't want the default configured logger.  Note that the
+		# +change_logger+ version is preferred because Ruby will often parse
+		# <tt>logger = Logger.new</tt> as the declaration of, and assignment
+		# to, of a local variable.	You'd need to do
+		# <tt>self.logger=Logger.new</tt> to be sure.  This method is a bit
+		# easier.
+		#
+		# +new_logger+:: the new logger.	May not be nil and should be a logger of some kind
+		def change_logger(new_logger)
+			raise ArgumentError,"Logger may not be nil" if new_logger.nil?
+			@@logger = new_logger
+			@@logger.level = @log_level if @log_level
+		end
+
+		alias logger= change_logger
+
+		LOG_LEVELS = {
+			'debug' => Logger::DEBUG,
+			'info' => Logger::INFO,
+			'warn' => Logger::WARN,
+			'error' => Logger::ERROR,
+			'fatal' => Logger::FATAL,
+		}
+
+		#log the action and execute it
+		#Severity is Logger:: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+		def log_and_do(*args, severity: Logger::INFO, definee: self, **opts, &block)
+			msg="log_and_do #{args} on #{self}"
+			msg+=" with options #{opts}" unless opts.empty?
+			msg+=" with block #{block}" if block
+			logger.add(severity,msg)
+			if opts.empty?
+				definee.send(*args, &block)
+			else
+				definee.send(*args, **opts, &block)
+			end
+		end
+
+		#Include this in place of CLILogging if you prefer to use
+		#info directly rather than logger.info
+		module Shortcuts #{{{
+			extend self
+			include CLILogging
+
+			def debug(progname = nil, &block); logger.debug(progname,&block); end
+			def info(progname = nil, &block); logger.info(progname,&block); end
+			def warns(progname = nil, &block); logger.warn(progname,&block); end
+			def error(progname = nil, &block); logger.error(progname,&block); end
+			def fatal(progname = nil, &block); logger.fatal(progname,&block); end
+		end
+		#}}}
+	end #}}}
+end

data/lib/shell_helpers/pathname.rb

@@ -0,0 +1,159 @@
+require 'pathname'
+
+#backports from ruby 2.1
+class Pathname
+	unless method_defined?(:write)
+		def write(*args,&b)
+			IO.write(self,*args,&b)
+		end
+	end
+	unless method_defined?(:to_path)
+		alias to_path to_str
+	end
+end
+
+autoload :FileUtils, "fileutils"
+
+module SH
+	#SH::Pathname is Pathname with extra features
+	#and methods from FileUtils rather than File when possible
+	#to use this module rather than ::Pathname in a module or class,
+	#simply define Pathname=SH::Pathname in an appropriate nesting level
+	class Pathname < ::Pathname
+		def hidden?
+			return self.basename.to_s[0]=="."
+		end
+
+		def filewrite(*args,mode:"w",perm: nil,mkdir: false)
+			logger.debug("Write to #{self}"+ (perm ? " (#{perm})" : "")) if respond_to?(:logger)
+			self.dirname.mkpath if mkdir
+			self.open(mode: mode) do |fh|
+				fh.chmod(perm) if perm
+				#hack to pass an array to write and do the right thing
+				if args.length == 1 && Array === args.first
+					fh.puts(args.first)
+				else
+					fh.write(*args)
+				end
+				yield fh if block_given?
+			end
+		end
+		#write is not the same as filewrite
+		#but if given only one argument we should be ok
+		unless Pathname.method_defined?(:write)
+			alias :write :filewrite
+		end
+
+		#Pathname.new("foo")+"bar" return "foo/bar"
+		#Pathname.new("foo").append_name("bar") return "foobar"
+		def append_name(*args,join:'')
+			Pathname.new(self.to_s+args.join(join))
+		end
+
+		def backup(suffix: '.old', overwrite: true)
+			if self.exist?
+				filebk=self.append_name(suffix)
+				if filebk.exist? and !overwrite
+					num=0
+					begin
+						filebknum=filebk.append_name("%02d" % num)
+						num+=1
+					end while filebknum.exist?
+					filebk=filebknum
+				end
+				logger.debug "Backup #{self} -> #{filebk}" if respond_to?(:logger)
+				FileUtils.mv(self,filebk)
+			end
+		end
+
+		def abs_path(base: Pathname.pwd, mode: :clean)
+			f=base+self
+			case clean
+			when :clean
+				f.cleanpath
+			when :clean_sym
+				f.cleanpath(consider_symlink: true)
+			when :real
+				f.realpath
+			when :realdir
+				f.realdirpath
+			end
+		end
+
+		#wrapper around FileUtils
+		#Pathname#rmdir uses Dir.rmdir, but the rmdir from FileUtils is a wrapper
+		#around Dir.rmdir that accepts extra options
+		#The same for mkdir
+		[:chdir, :rmdir, :mkdir].each do |method|
+			define_method method do |*args,&b|
+				FileUtils.send(method,*args,&b)
+			end
+		end
+		#mkpath is already defined (use FileUtils), but not mkdir_p
+		#alias mkdir_p mkpath
+
+		#Options: verbose, noop, force
+		def rm(recursive: false, mode: :file, verbose: true, noop: false, force: false)
+			mode.to_s.match(/^recursive-(.*)$/) do |m|
+				recursive=true
+				mode=m[1].to_sym
+			end
+			case mode
+			when :symlink
+				return unless self.symlink?
+			when :dangling_symlink
+				return unless self.symlink? && ! self.exist?
+			end
+			if recursive
+				FileUtils.rm_r(self, verbose: verbose, noop: noop, force: force)
+			else
+				FileUtils.rm(self, verbose: verbose, noop: noop, force: force)
+			end
+		rescue => e
+			warn "Error in #{self}.clobber: #{e}"
+		end
+
+		#Options: preserve noop verbose
+		def cp(*files,**opts)
+			FileUtils.cp(files,self,**opts)
+		end
+		#Options: force noop verbose
+		def mv(*files,**opts)
+			FileUtils.mv(files,self,**opts)
+		end
+
+		#find already exists
+		def dr_find(*args,&b)
+			require 'dr/sh/utils'
+			SH::ShellUtils.find(self,*args,&b)
+		end
+
+		def self.home
+			return Pathname.new(Dir.home)
+		end
+		def self.hometilde
+			return Pathname.new('~')
+		end
+		def self.slash
+			return Pathname.new("/")
+		end
+		#differ from Pathname.pwd in that this returns a relative path
+		def self.current
+			return Pathname.new(".")
+		end
+		def self.null
+			return Pathname.new('/dev/null')
+		end
+
+		#Pathname / 'usr'
+		def self./(path)
+			new(path)
+		end
+		#Pathname['/usr']
+		def self.[](path)
+			new(path)
+		end
+
+	end
+
+end

data/lib/shell_helpers/run.rb

@@ -0,0 +1,139 @@
+# vim: foldmethod=marker
+require 'open3'
+require 'shellwords'
+
+module SH
+	module Run #{{{
+		extend(self)
+		#the run_* commands here capture all the output
+		def run_command(*command)
+			return Open3.capture3(*command)
+		end
+
+		def run_output(*command)
+			stdout,_stderr,_status = run_command(*command)
+			return stdout
+		end
+
+		def run_status(*command)
+			_stdout,_stderr,status = run_command(*command)
+			return status.success?
+		end
+
+		#a simple wrapper for %x//
+		def run_simple(*command, quiet: false, fail_mode: :error, chomp: false)
+			if command.length > 1
+				launch=command.shelljoin
+			else
+				launch=command.first
+			end
+			launch+=" 2>/dev/null" if quiet
+			begin
+				out = %x/#{launch}/
+				status=$?.success?
+			rescue => e
+				status=false
+				case fail_mode
+				when :error
+					raise e
+				when :empty
+					out=""
+				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?
+				else
+					out = `#{args.shelljoin} 2>/dev/null`
+					status=$?
+					return out, status.success?
+				end
+			end
+		end
+
+		#same as Run, but if we get interrupted once, we don't want to launch any more commands
+		module Interrupt #{{{
+			extend(self)
+			@interrupted=false
+			def run_command(*args)
+				if !@interrupted
+					begin
+						DR::Run.run_command(*args)
+					rescue Interrupt #interruption
+						@interrupted=true
+						return "", "", false
+					end
+				else
+					return "", "", false
+				end
+			end
+
+			def run(*command)
+				if !@interrupted
+					begin
+						return DR::Run.run(*args)
+					rescue Interrupt #interruption
+						@interrupted=true
+						return "", false
+					end
+				else
+					return "", false
+				end
+			end
+		end #}}}
+	end #}}}
+
+	# ProcessStatus {{{
+	# from methadone (process_status.rb; last import v1.3.1-2-g9be3b5a)
+	#
+	# A wrapper/enhancement of Process::Status that handles coercion and expected
+	# nonzero statuses
+	class ProcessStatus
+
+		# The exit status, either directly from a Process::Status, from the exit code, or derived from a non-Int value.
+		attr_reader :exitstatus, :status
+
+		# Create the ProcessStatus with the given status.
+		# respond to success?,exitstatus,status
+		#
+		# status:: if this responds to #exitstatus, that method is used to extract the exit code.  If it's an Int, that is used as the exit code.  Otherwise, it's truthiness is used: 0 for truthy, 1 for falsey.
+		# expected:: an Int or Array of Int representing the expected exit status, other than zero, that represent "success".
+		#Ex usage: stdout,stderr,status = DR::Run.run_command(*command,**opts)
+		#process_status = DR::ProcessStatus.new(status,expected)
+		def initialize(status,expected=nil)
+			@status=status
+			@exitstatus = derive_exitstatus(status)
+			@success = ([0] + Array(expected)).include?(@exitstatus)
+		end
+
+		# True if the exit status was a successul (i.e. expected) one.
+		def success?
+			@success
+		end
+
+		private
+
+		def derive_exitstatus(status)
+			status = if status.respond_to? :exitstatus
+								 status.exitstatus
+							 else
+								 status
+							 end
+			if status.kind_of? Fixnum
+				status
+			elsif status
+				0
+			else
+				1
+			end
+		end
+	end
+	# }}}
+end

data/lib/shell_helpers/sh.rb

@@ -0,0 +1,244 @@
+# 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'
+
+module SH
+	# ExitNow {{{
+	# Standard exception you can throw to exit with a given status code.
+	# Generally, you should prefer DR::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.
+	class ExitError < StandardError
+		attr_reader :exit_code
+		# Create an Error with the given status code and message
+		def initialize(exit_code,message=nil)
+			super(message)
+			@exit_code = exit_code
+		end
+	end
+
+	# Provides #exit_now! You might mix this into your business logic classes
+	# if they will need to exit the program with a human-readable error
+	# message.
+	module ExitNow
+		# Call this to exit the program immediately
+		# with the given error code and message.
+		# +exit_code+:: exit status you'd like to exit with
+		# +message+:: message to display to the user explaining the problem
+		# If +exit_code+ is a String and +message+ is omitted, +exit_code+ will
+		# === Examples
+		#			exit_now!(4,"Oh noes!")
+		#				# => exit app with status 4 and show the user "Oh noes!" on stderr
+		#			exit_now!("Oh noes!")
+		#				# => exit app with status 1 and show the user "Oh noes!" on stderr
+		#			exit_now!(4)
+		#				# => exit app with status 4 and dont' give the user a message (how rude of you)
+		def exit_now!(exit_code,message=nil)
+			if exit_code.kind_of?(String) && message.nil?
+				raise ExitError.new(1,exit_code)
+			else
+				raise ExitError.new(exit_code,message)
+			end
+		end
+	end
+	# }}}
+	# Sh {{{
+	# Module with various helper methods for executing external commands.
+	# In most cases, you can use #sh to run commands and have decent logging
+	# done.
+	# == Examples
+	#
+	#		 extend SH::Sh
+	#
+	#		 sh 'cp foo.txt /tmp'
+	#		 # => logs the command to DEBUG, executes the command, logs its output to DEBUG and its error output to WARN, returns 0
+	#
+	#		 sh 'cp non_existent_file.txt /nowhere_good'
+	#		 # => logs the command to DEBUG, executes the command, logs its output to INFO and its error output to WARN, returns the nonzero exit status of the underlying command
+	#
+	#		 sh! 'cp non_existent_file.txt /nowhere_good'
+	#		 # => same as above, EXCEPT, raises a Methadone::FailedCommandError
+	#
+	#		 sh 'cp foo.txt /tmp' do
+	#			 # Behaves exactly as before, but this block is called after
+	#		 end
+	#
+	#		 sh 'cp non_existent_file.txt /nowhere_good' do
+	#			 # This block isn't called, since the command failed
+	#		 end
+	#
+	#		 sh 'ls -l /tmp/' do |stdout|
+	#			 # stdout contains the output of the command
+	#		 end
+	#		 sh 'ls -l /tmp/ /non_existent_dir' do |stdout,stderr|
+	#			 # stdout contains the output of the command,
+	#			 # stderr contains the standard error output.
+	#			end
+
+	# FailedCommandError {{{
+	# Thrown by certain methods when an externally-called command exits nonzero
+	class FailedCommandError < StandardError
+		# The command that caused the failure
+		attr_reader :command
+		# exit_code:: exit code of the command that caused this
+		# command:: the entire command-line that caused this
+		# custom_error_message:: an error message to show the user instead of
+		# the boilerplate one.	Useful for allowing this exception to bubble up
+		# and exit the program, but to give the user something actionable.
+		def initialize(exit_code,command,failure_msg: nil)
+			error_message = String(failure_msg).empty? ?	"Command '#{command}' exited #{exit_code}" : failure_msg
+			super(error_message)
+			@command = command
+		end
+	end
+	# }}}
+
+	module Sh
+		include CLILogging
+		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,
+			log_level_stderr: :error, log_level_stdout_success: :info,
+			log_level_stdout_fail: :warn}
+		end
+
+		# Run a shell command, capturing and logging its output.
+		# keywords:: log+capture
+		# If the command completed successfully, it's output is logged at DEBUG.
+		# If not, its output is logged at INFO.  In either case, its
+		# error output is logged at WARN.
+		#						+:expected+:: an Int or Array of Int representing error codes, <b>in addition to 0</b>, that are expected and therefore constitute success.  Useful for commands that don't use exit codes the way you'd like
+		#			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
+		#					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
+		#			sh "cp foo /tmp"
+		#			sh "ls /tmp" do |stdout|
+		#				# stdout contains the output of ls /tmp
+		#			end
+		#			sh "ls -l /tmp foobar" do |stdout,stderr|
+		#				# ...
+		#			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
+			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.shelljoin if curopts[:escape]
+			sh_logger.send(curopts[:log_level_execute], SimpleColor.color("Executing '#{command_name}'",:bold)) if log
+
+			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)
+					end
+				else
+					case command
+					when Array
+						system(*command,**opts)
+					else
+						system(command.to_s,**opts)
+					end
+					status=$?
+					stdout=nil; stderr=nil
+				end
+			else
+				puts command.to_s
+				status=0
+				stdout=nil; stderr=nil
+			end
+			process_status = ProcessStatus.new(status,curopts[:expected])
+
+			sh_logger.send(curopts[:log_level_stderr], SimpleColor.color("stderr output of '#{command_name}':\n",:bold,:red)+stderr) unless stderr.nil? or stderr.strip.length == 0 or !log
+			if process_status.success?
+				sh_logger.send(curopts[:log_level_stdout_success], SimpleColor.color("stdout output of '#{command_name}':\n",:bold,:green)+stdout) unless stdout.nil? or stdout.strip.length == 0 or !log
+				curopts[:on_success].call(stdout,stderr,process_status) unless curopts[:on_success].nil?
+				block.call(stdout,stderr,process_status) unless block.nil?
+			else
+				sh_logger.send(curopts[:log_level_stdout_fail], SimpleColor.color("stdout output of '#{command_name}':\n",:bold,:yellow)+stdout) unless stdout.nil? or stdout.strip.length == 0 or !log
+				sh_logger.send(curopts[:log_level_error], SimpleColor.color("Error running '#{command_name}': #{process_status.status}",:red,:bold)) if log
+				curopts[:on_failure].call(stdout,stderr,process_status) unless curopts[:on_failure].nil?
+			end
+			return process_status.success?,stdout,stderr,process_status
+
+		rescue SystemCallError => ex
+			sh_logger.send(curopts[:log_level_error], SimpleColor.color("Error running '#{command_name}': #{ex.message}",:red,:bold)) if log
+			return 127
+		end
+
+		# Run a command, throwing an exception if the command exited nonzero.
+		# Otherwise, behaves exactly like #sh.
+		# Raises DR::FailedCommandError if the command exited nonzero.
+		# Examples:
+		#
+		#			sh!("rsync foo bar")
+		#			# => if command fails, app exits and user sees: "error: Command 'rsync foo bar' exited 12"
+		#			sh!("rsync foo bar", :failure_msg => "Couldn't rsync, check log for details")
+		#			# => if command fails, app exits and user sees: "error: Couldn't rsync, check log for details
+		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)
+			end
+			sh(*args,**opts,on_failure: on_failure,&block)
+		end
+
+		# Override the default logger (which is the one provided by CLILogging).
+		# You would do this if you want a custom logger or you aren't mixing-in
+		# CLILogging.
+		#
+		# Note that this method is *not* called <tt>sh_logger=</tt> to avoid annoying situations
+		# where Ruby thinks you are setting a local variable
+		def change_sh_logger(logger)
+			@sh_logger = logger
+		end
+
+	private
+		def command_name(command)
+			if command.size == 1
+				return command.first.to_s
+			else
+				return command.to_s
+			end
+		end
+
+		def sh_logger
+			@sh_logger ||= begin
+				raise StandardError, "No logger set! Please include DR::CLILogging
+ng or provide your own via #change_sh_logger." unless self.respond_to?(:logger)
+				self.logger
+			end
+		end
+
+	end
+
+	#SH::ShLog.sh is like SH::Sh.sh but with login enabled even when
+	#command succeed
+	module ShLog
+		include Sh
+		extend self
+		@default_sh_options=default_sh_options
+		@default_sh_options[:log]=true
+		@default_sh_options[:log_level_execute]=:info
+	end
+	# }}}
+end

data/lib/shell_helpers/utils.rb

@@ -0,0 +1,226 @@
+require 'shellwords'
+require 'dr/ruby_ext/core_ext'
+require_relative 'pathname'
+require_relative 'parser'
+
+module SH
+	module ShellExport
+		extend self
+
+		#export a value for SHELL consumption
+		def export_value(v)
+			case v
+				when String
+					return v.shellescape
+				when Array
+					return "(#{v.map {|i| i.to_s.shellescape}.join(' ')})"
+				when Hash
+					return "(#{v.map {|k,v| k.to_s.shellescape+" "+v.to_s.shellescape}.join(' ')})"
+				when nil
+					return ""
+				else
+					return v.to_s.shellescape
+			end
+		end
+
+		#from {ploum: plim} return something like
+		#ploum=plim
+		#that can be evaluated by the shell
+		def export_hash(hash, local: false, export: false, prefix:"")
+			r=""
+			r+="local #{hash.keys.map {|s| s.to_s.upcase}.join(" ")}\n" if local
+			hash.each do |k,v|
+				name=prefix+k.to_s.upcase
+				r+="typeset -A #{name};\n" if Hash === v
+				r+=name+"="+export_value(v)+";\n"
+			end
+			r+="export #{hash.keys.map {|k| prefix+k.to_s.upcase}.join(" ")}\n" if export
+			return r
+		end
+
+		#export_variable("ploum","plam") yields ploum="plam"
+		def export_variable(name, value, local: false, export: false)
+			r=""
+			#name=name.upcase
+			r+="local #{name}\n" if local
+			r+="typeset -A #{name};\n" if Hash === value
+			r+=name+"="+export_value(value)+";\n"
+			r+="export #{name}\n" if export
+			return r
+		end
+
+		#export_parse(hash,"name:value")
+		#will output name=$(hash[value])
+		#special cases: when value = '/' we return the full hash
+		#		when value ends by /, we return the splitted hash (and name serves
+		#		as a prefix)
+		#Ex: Numenor ~ $ ./mine/00COMPUTERS.rb --export=//
+		#		 HOSTNAME=Numenor;
+		#		 HOSTTYPE=perso;
+		#		 HOMEPATH=/home/dams;...
+		#		 Numenor ~ $ ./mine/00COMPUTERS.rb --export=syst/
+		#		 LAPTOP=true;
+		#		 ARCH=i686;...
+		#Remark: in name:value, we don't put name in uppercase
+		#But in split hash mode, we put the keys in uppercase (to prevent collisions)
+		def export_parse(hash,s)
+			r=""
+			args=Parser.parse_string(s)
+			args[:values].each do |k,v|
+				name=k
+				if !v
+					v=name
+					#in split mode, don't use prefix if name gave the value
+					name= name.size==1? "all" : "" if name[name.size-1]=="/"
+				end
+				if v.size>1 && v[v.size-1]=='/'
+					all=true
+					v=v[0...v.size-1]
+				end
+				value=hash.keyed_value(v)
+				if all
+					r+=export_hash(value, local: args[:opts][k]["local"], export: args[:opts][k]["export"], prefix: name)
+				else
+					r+=export_variable(name,value, local: args[:opts][k]["local"], export: args[:opts][k]["export"])
+				end
+			end
+			return r
+		end
+	end
+
+	module ShellUtils
+		extend self
+
+		class << self
+			attr_accessor :orig_stdin, :orig_stdout, :orig_stderr
+		end
+		@orig_stdin=$stdin
+		@orig_stdout=$stdout
+		@orig_stderr=$stderr
+
+		#An improved find from Find::find that takes in the block the absolute and relative name of the files (+the directory where the relative file is from), and has filter options
+		def find(*paths, filter: nil, follow_symlink: false, depth: nil)
+			block_given? or return enum_for(__method__, *paths, filter: filter, follow_symlink: follow_symlink, depth: depth)
+
+			paths.collect!{|d| raise Errno::ENOENT unless File.exist?(d); Pathname.new(d.dup)}
+			paths.collect!{|d| [ d, Pathname.new('.'), d ]}
+			while filedata = paths.shift
+				file, filerel, fileabs = *filedata
+				catch(:prune) do #use throw(:prune) to skip a path
+					Dir.chdir(fileabs) do
+						#if the filter is true, we don't yield the file
+						case filter
+						when Proc
+							filter.call(file,filerel,fileabs)
+						when Array
+							filter.all? do |test|
+								case test
+								when :directory? #special case
+									file.directory? && !file.symlink?
+								else
+									file.send(test)
+								end
+							end
+						end or yield file.dup.taint, filerel.dup.taint, fileabs.dup.taint
+						if file.directory? and (depth.nil? or filerel.each_filename.size <= depth) then
+							next if !follow_symlink && file.symlink?
+							file.children(false).sort.reverse_each do |f|
+								fj = file + f
+								f = filerel + f
+								paths.unshift [fj.untaint,f.untaint,fileabs]
+							end
+						end
+					end
+				end
+			end
+		end
+
+		#all output is sent to the pager
+		def run_pager(opt=nil)
+			return unless $stdout.tty? and opt != :never
+			read, write = IO.pipe
+
+			unless Kernel.fork # Child process
+				$stdout.reopen(write)
+				$stderr.reopen(write) if $stderr.tty?
+				read.close
+				write.close
+				return
+			end
+
+			# Parent process, become pager
+			$stdin.reopen(read)
+			read.close
+			write.close
+
+			#ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+			lessenv=ENV['LESS']
+			lessenv="-FRX" if lessenv.empty?
+			lessenv+="F" unless lessenv.match(/F/) or opt == :always
+			lessenv+="R" unless lessenv.match(/R/)
+			lessenv+="X" unless lessenv.match(/X/)
+			ENV['LESS']=lessenv
+
+			Kernel.select [$stdin] # Wait until we have input before we start the pager
+			pager = ENV['PAGER'] || 'less'
+			exec pager rescue exec "/bin/sh", "-c", pager
+		end
+
+		#inside run_pager, escape from the pager
+		#does not work :-(
+		def escape_pager(mode=nil)
+			case mode
+			when :orig
+				stdout=ShellUtils.orig_stdout
+				stderr=ShellUtils.orig_stderr
+				stdin=ShellUtils.orig_stdin
+			else
+				stdout=STDOUT
+				stderr=STDERR
+				stdin=STDIN
+			end
+			$stdout.reopen(stdout)
+			$stderr.reopen(stderr)
+			$stdin.reopen(stdin)
+		end
+
+		def output_list(s, split: "\n")
+			s=s.shelljoin if s.kind_of?(Array)
+			return open("| #{s}").read.split(split)
+		end
+
+		#Stolen from mkmf:
+		# Searches for the executable +bin+ on +path+.	The default path is your
+		# +PATH+ environment variable. If that isn't defined, it will resort to
+		# searching /usr/local/bin, /usr/ucb, /usr/bin and /bin.
+		# If found, it will return the full path, including the executable name, of
+		# where it was found.
+		# exts: an array of extensions to add
+		def find_executable(bin, path = nil, exts: nil)
+			executable_file = lambda do |name|
+				name=Pathname.new(name)
+				return name if name.file? and name.executable?
+			end
+			#we use Proc so that 'return' escapes the block
+			try_executable = Proc.new do |file|
+				return file if executable_file.call(file)
+				exts && exts.each {|ext| executable_file.call(ext = file.append_name(ext)) and return ext}
+				nil
+			end
+
+			bin=Pathname.new(bin)
+			if bin.absolute?
+				try_executable.call(bin)
+			else
+				path ||= ENV['PATH'] || %w[/usr/local/bin /usr/bin /bin]
+				path = path.split(File::PATH_SEPARATOR) unless path.kind_of?(Array)
+				path.each do |dir|
+					dir=Pathname.new(dir)
+					try_executable.call(dir+bin)
+				end
+			end
+			nil
+		end
+
+	end
+end

data/lib/shell_helpers/version.rb

@@ -0,0 +1,4 @@
+module ShellHelpers
+  # shell_helpers version
+  VERSION = "0.1.0"
+end

data/shell_helpers.gemspec

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'shell_helpers/version'
+                  ShellHelpers::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'rubygems'
+require 'minitest/autorun'

data/test/test_shell_helpers.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'shell_helpers'
+
+class TestShellHelpers < Minitest::Test
+
+  def test_version
+    version = ShellHelpers.const_get('VERSION')
+
+    assert(!version.empty?, 'should have a VERSION constant')
+  end
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: shell_helpers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Damien Robert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: drain
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: 'Collection of script to ease working with the shell with ruby.
+
+'
+email: Damien.Olivier.Robert+gems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".yardopts"
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- lib/shell_helpers.rb
+- lib/shell_helpers/logger.rb
+- lib/shell_helpers/pathname.rb
+- lib/shell_helpers/run.rb
+- lib/shell_helpers/sh.rb
+- lib/shell_helpers/utils.rb
+- lib/shell_helpers/version.rb
+- shell_helpers.gemspec
+- test/helper.rb
+- test/test_shell_helpers.rb
+homepage: https://github.com/DamienRobert/shell_helpers#readme
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Shell Helpers
+test_files: []