shell_helpers 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6049045c2830e61e0ea865aeb4905e0f4464cdd4b837ee0e7923667e8aae7900
-  data.tar.gz: 2ca9a6fceac250538239f8ff3b075d4d2813b02892f7dad411dfad0a8dbfd1e7
+  metadata.gz: 42ce008456bb9f4bd37bea823f9d0886483c647e76ff265c571810c0e72963bf
+  data.tar.gz: cd0ee20f0fb67c4d48eb1571ae90679fc310ffc2cfc0b7b980f0beeae28e086c
 SHA512:
-  metadata.gz: 809023e14ecf8fc382ce25f107eeeba053573e190fac4030641a496e74306d3f480ef6b4555f5ffb71b9e412bf4f95778c78ab7bdf27efa7a517f92c1239c69c
-  data.tar.gz: 6db15aa50cb2ee5d60ee85404a109b00f8106aad9491b993c6aed289f2f23fd838d65124501a617672cf3e9fa06360aef525177199fedaa1b47362622b6a673c
+  metadata.gz: 7c50ff0378d2e1519a595eed19988e49be241c9d437e0d4338f7be8761eb468e3656162ebe78504d36decdc57dad3c52472d47c1ad6a330a98cb45d05ce4ded5
+  data.tar.gz: 6abc73549c5699ff2ae5355a475f1cffafcf0b584461764f6aa249c86df97e2f74602ce30fb9ffca3db865307917c56360caab44606c2b33775500ac51934ab8

data/ChangeLog.md

@@ -1,4 +1,238 @@
-### 0.1.0 / 2015-02-24
+== Release v0.7.0 (2020-02-18) ==
 
-* Initial release:
+	* Copyright
+	* rsync: Use -zz instead of -z (--new-compress)
+	* Fixes for ruby 2.7
+	* rsync: add clobber option
+	* logger: fix logger.debug {"foo"}
+	* sysutils.rb: add exemples
+	* Misc bug fixes and doc
+	* sh.rb: correct examples
+	* Pathname.read!
+	* pathname: old_glob -> rel_glob
+	* pathname: deprecate glob, it is now a builtin
+	* logger: fix output showing twice
+	* Bug fix
+	* Fix tests
+	* Small tweaks
+	* logger2.rb is now logger.rb
+	* logger2: bug fixes
+	* logger2.rb: continue merge
+	* logger2: Merge MoreLogger and ColorLogger
+	* Rework MoreLogger
+	* SH: log_options (for OptParse)
+	* Fix tests
+	* logger.rb: new class ColorLogger
+	* logger: cli_info -> not bold
+	* Logger: cli_methods configuration
+	* logger: small tweaks
+	* tests for logger
+	* Logger: cli_*
+	* Update Rakefile
+	* Update Rakefile
+	* logger.rb: add bold
+	* logger: color_add
+	* severity: debug1=debug and verbose1=verbose
+	* logger: verbose* levels
+	* Logger#cli_level: helper to set up log level
+	* logger: debug1, debug2, debug3
+	* run.rb: bug fixes
+	* Bug fixes
+	* SH.log
+	* Sh: use instance_method for run_sudo_loop
+	* pathname: add missing require
+	* ssh: ssh_env option to pass env to the remote
+	* Run#run_success
+	* SH.sh: by default only return success
+	* Sh.sh: specify argv0
+	* Sh.sh: accept a block
+	* Sh: sudo_loop
+	* Sh#sh_or_proc
+	* Bug fixes
+
+== Release v0.6.0 (2018-09-07) ==
+
+	* Bump version to 0.6.0
+
+== Release v0.3.0 (2018-09-07) ==
+
+	* Bump version
+	* run+sh: unify command handling
+	* logger.rb: add quiet
+	* SH.sh: sudo can be a complex command
+	* Bug fixes + better logging for sh
+	* ShConfig + VirtualFile
+	* ShConfig: remove context
+	* ShConfig: wrap
+	* Sh: ShConfig
+	* Excpetions: subclass StandardError
+	* Run: bug fix
+	* Run.run: add :quiet alias for error: :quiet
+	* Run.run: replace status_mode by error_mode to be clearer
+	* run: accept environments, wrap into ProcessStatus if needed
+	* run.rb: run_simple now calls run
+	* sysutils: small improvements
+	* Sysutils: partition_infos + bug fixes
+	* Pathname#readbin
+	* SH.sh: detach vs spawn
+	* ssh: use URI::Ssh to be more lenient for host name
+	* Rsync exclude: escape
+	* Clean up
+	* Rsync: exclude
+	* utils: refactor
+	* rsync: add sshcommand option
+	* ssh: :sshkit and :net_ssh modes
+	* Pathname: add logging
+	* SH.sh: allow mode to be :exec too
+	* Utils.ssh: more mode, and split ssh_command
+	* Utils.ssh: user
+	* Utils.ssh:
+	* sysutils: bug fix
+	* Pathname#glob: expand to pathname
+	* Pathname#rel_path_to: convert the target to a Pathname
+	* sysutils: allows mountoptions to be a String
+	* Remove LogHelper
+	* sh.rb: change execute log level to be :info
+	* Utils: eval_shell
+	* Bug fix
+	* Bug fix
+	* make_dir_or_subvolume
+	* sysutils: stat_files
+	* sysutils: bug fixes
+	* sysutils: check devices for name too
+	* sysutils: block handling to automatically unmount
+	* sysutils: use Pathname#<=>
+	* run/sh: add a 'sudo' option
+	* sysutils: improve find_devices
+	* sysutils: fs_infos return a hash rather than an array
+	* sysutils: unify keywords for blkid, lsblk, findmnt
+	* sysutils: lsblk and findmnt
+	* sysutils: partition types
+	* sysutils: commands for sysadmins
+	* pathname: chown
+	* rsync: more convenient options passing
+	* Copyright
+	* rsync: correct a typo
+	* Wrap chdir
+	* SH::Sh: Add DryRun module
+	* Pathname: misc utils functions
+	* Sh.sh: correctly handle false options
+	* docs typos
+	* Sh: activates logging by default
+	* sh_commands: chomp newline
+
+== Release v0.2.0 (2018-02-01) ==
+
+	* Bump versions
+	* rsync: add chown option
+	* Pathname#{text?,binary?}: return false on a directory
+	* run.rb: improve api
+	* Import changes from methadone
+	* binary?: Encoding to ascii would lose to many bits
+	* Pathname#text? Don't invoke 'file'
+	* Pathname#text?, Pathname#glob
+	* run_lazy: simplify the implementation
+	* run: add run_enum
+	* run_pager: can pass arguments to the pager
+	* Be explicit about require
+	* Add missing options lib
+	* Fix require
+	* Split utils.rb into utils.rb and export.rb
+	* Pathname#hidden? was defined twice
+	* Add badges
+	* In travis the test should be under 'bundle exec'
+	* We need the git version of drain for now
+	* Update gemspec
+	* Add rake dependency
+	* Configure travis and streamline rake and test files
+	* rsync: using relative we usually want no-implied-dirs
+	* utils: more rsync options
+	* import_parse: inline mode
+	* utils: add capture_stdout
+	* shrun: helper to run system/spawn with the correct options
+	* sh: Pass along options
+	* logger: progname should affect the error logger too
+	* SH.sh: allow to detach
+	* bugfix
+	* Unquote value
+	* utils.rb: put import_parse in the correct Module
+	* import_variable: match variable name on \S*
+	* test import_parse
+	* Import variables
+	* Copyright
+	* export_value: test if the object respond to :to_a or :to_h
+	* test: test_utils.rb (only ShellExport for now)
+	* Fixes for ruby 2.4
+	* find: handle max_depth
+	* utils: when exporting a group/name variable replace '/' with '_'
+	* Copyright
+	* Add examples
+	* Pathname.cd
+	* find_files
+	* find_file
+	* RunSimple: add error: nil
+	* Add pathname#split_all
+	* Pathname: add may_exist?
+	* Pathname: add chattr
+	* More documentation on SH.find
+	* FileUtils#chmod requires the mode as first parameter
+	* rsync: the option is --suffix, not --backup-suffix
+	* rsync: Add expected: 23
+	* rsync: add option to clean output directory
+	* rsync: add :delete option
+	* Add rsync helper
+	* Rename Sh#commands to Sh#sh_commands
+	* Add Sh.commands
+	* Add Pathname#copy_entry
+	* rmtree should be an alias to rm_rf
+	* Add backup mode to filewrite, and mkpath mode ton on_*
+	* Add rsync helper
+	* Pathname#squel_dir: allow to pass mkpath
+	* SH.find now accept a :prune options
+	* We should check if CLILogging has @@logger, not Module
+	* Move options.rb to another library
+	* mv_and_ln.rb: dereference
+	* mv_and_ln: options tweaks
+	* Add mv_and_ln.rb
+	* Pathname: use convert_path in rel_path_to
+	* Handle relative_path_from errors
+	* Add new mode to not dereference symlink in some actions
+	* abs_to_rel.rb
+	* A binary using the features of pathname
+	* Inner scope
+	* Add helper functions
+	* find: add a depth first option
+	* find: rename depth to max_depth
+	* Pathname#squel_dir: we need to use squel inside the find
+	* Bugfixes in Pathname and ShUtils.find
+	* Pathname#squel_dir
+	* Start working on Pathname#squel
+	* Pathname: add rel_path_from
+	* Use included hooks
+	* Put pathname functionality into Modules and Classes
+	* Correct constant reference
+	* Pathname: fix aliases
+	* SH::Pathname: put changes in module so that other class can use them
+	* Merge branch 'master-imb'
+	* Small bug fixes
+	* SH.find: any filter should prevent the yield
+	* Pathname: factorize the new name usual method
+	* Pathname: new_name
+	* Implement SH::Pathname#follow
+	* Add Pathname#rel_path
+	* Readme: Add warning
+	* pathname.rb: raise some Errors if needed
+	* Implement a 'magic' rm function
+	* Pathname: use FileUtils when possible
+	* Add a module LogHelper to help setup logging
+	* Add a fallback if SimpleColor is not found
+	* Some files/names have changed
+	* Rename SH to ShellHelpers
+
+== Release v0.1.0 (2015-02-24) ==
+
+	* Add dependency
+	* Description
+	* Add library
+	* Initial commit.
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright © 2015–2018 Damien Robert
+Copyright © 2015–2020 Damien Robert
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,15 +1,5 @@
 require 'rake'
 
-begin
-  require 'rubygems/tasks'
-  Gem::Tasks.new(sign: {checksum: true, pgp: true}, 
-    scm: {status: true}) do |tasks|
-  tasks.console.command = 'pry'
-end
-rescue LoadError => e
-  warn e.message
-end
-
 require 'rake/testtask'
 Rake::TestTask.new do |test|
   test.libs << 'test'
@@ -27,3 +17,10 @@ rescue LoadError => e
 end
 task :doc => :yard
 
+begin
+  require 'dr/rake_gems'
+  Gem::MyTasks.new
+rescue LoadError => e
+  warn e.message
+end
+

data/gemspec.yml

@@ -9,6 +9,7 @@ homepage: https://github.com/DamienRobert/shell_helpers#readme
 
 dependencies:
   drain: ~> 0.2
+  simplecolor: ~> 0.2
 development_dependencies:
   minitest: "~> 5.0"
   rake: "~> 10"

data/lib/shell_helpers.rb

@@ -23,37 +23,75 @@ module ShellHelpers
 	include Export #export
 	include Utils #find, run_pager, rsync...
 	include SysUtils #mount, find_devices...
-	extend self
-	#activates debug mode
-	def self.debug(level=Logger::DEBUG)
-		#activates logging on Pathname
-		Pathname.send(:include, CLILogging)
-		logger.level=(level)
+
+	module LogHelpers
+		#activates debug mode
+		def debug(level=true)
+			#activates logging on Pathname
+			Pathname.send(:include, CLILogging)
+			logger.cli_level(level, active: Logger::DEBUG)
+		end
+
+		def log(*args, **kw)
+			logger.add(*args, **kw)
+		end
+
+		# add standard log options to an OptParse instance
+		def log_options(opt, recipient)
+			opt.on("--[no-]color", "Colorize output", "Default to #{recipient[:color]}") do |v|
+				recipient[:color]=v
+			end
+
+			opt.on("--debug", "=[level]", "Activate debug informations", "Use `--debug=pry` to launch the pry debugger", "Default to #{recipient[:debug]}") do |v|
+				recipient[:debug]=v
+			end
+
+			opt.on("--log", "=[level]", "Set log level", "Default to #{recipient[:loglevel]}.") do |v|
+				recipient[:loglevel]=v
+			end
+
+			opt.on("--[no-]verbose", "-v", "Verbose mode", "Similar to --log=verbose") do |v|
+				recipient[:loglevel]=:verbose if v
+			end
+
+			opt.on("--vv", "Verbose mode 2", "Similar to --log=verbose2") do |v|
+				recipient[:loglevel]=:verbose2 if v
+			end
+
+			opt.on("--vvv", "Verbose mode 3", "Similar to --log=verbose3") do |v|
+				recipient[:loglevel]=:verbose3 if v
+			end
+
+			opt.on("--[no-]quiet", "-q", "Quiet mode", "Similar to --log=warn") do |v|
+				recipient[:loglevel]=:warn if v
+			end
+		end
+
+		def process_log_options(recipient)
+			SimpleColor.enabled=recipient[:color] if recipient.key?(:color)
+			SH.logger.cli_level(recipient[:loglevel]) if recipient.key?(:loglevel)
+			if recipient.key?(:debug)
+				debug=recipient[:debug]
+				if debug=="pry"
+					puts "# Launching pry"
+					require 'pry'; binding.pry
+				elsif debug
+					SH.debug(debug)
+				end
+			end
+		end
 	end
+	include LogHelpers
+
+	extend self
+
 	#include SH::FU to add FileUtils
 	module FU
 		include ::FileUtils
 		include ::ShellHelpers
 		extend self
 	end
-
-	# #include LogHelper to set up CLILogging with some convenience facilities
-	# module LogHelper
-	# 	include CLILogging
-	# 	CLILogging.logger.progname||=$0
-	# 	# #Activates Sh.sh in klass
-	# 	# def self.included(klass)
-	# 	# 	klass.const_set(:Sh,ShellHelpers::Sh)
-	# 	# end
-	# end
 end
 
 #for the lazy
 SH=ShellHelpers
-
-## # SHLog.sh to get logging
-## module SHLog
-## 	include ShellHelpers
-## 	include ShellHelpers::ShLog
-## end
-

data/lib/shell_helpers/export.rb

@@ -82,13 +82,13 @@ module ShellHelpers
 		#from {ploum: plim} return something like
 		#PLOUM=plim
 		#that can be evaluated by the shell
-		def export_variables(hash, local: false, export: false, prefix:"",upcase:true)
+		def export_variables(hash, inline: false, local: false, export: false, prefix:"",upcase:true)
 			names=hash.keys.map {|s| escape_name(s,prefix:prefix,upcase:upcase)}
 			r=""
 			r+="local #{names.join(" ")}\n" if local
-			hash.each do |k,v|
-				r+=export_variable(k,v,prefix:prefix,upcase:upcase)
-			end
+			r+=hash.map do |k,v|
+				export_variable(k,v,prefix:prefix,upcase:upcase).chomp
+			end.join(inline ? " " : "\n") + (inline ? "" : "\n")
 			r+="export #{names.join(" ")}\n" if export
 			return r
 		end

data/lib/shell_helpers/logger.bak.rb

@@ -0,0 +1,481 @@
+# vim: foldmethod=marker
+#From methadone (cli_logger.rb, cli_logging.rb, last import: 4626a2bca9b6e54077a06a0f8e11a04fadc6e7ae; 2017-01-19)
+require 'logger'
+require 'simplecolor'
+
+module ShellHelpers
+	# like Logger but with more levels
+	class MoreLogger < Logger #{{{1
+		class Formatter < Logger::Formatter
+			def self.format_severity(severity)
+				Logger::SEV_LABEL[severity] || 'ANY'
+			end
+
+			def call(severity, time, progname, msg)
+				severity=self.class.format_severity(severity)
+				Format % [severity[0..0], format_datetime(time), $$, severity, progname,
+					msg2str(msg)]
+			end
+		end
+
+		WrongLevel=Class.new(StandardError)
+
+		module Levels
+			#note Logger::Severity is included into Logger, so we can access the severity levels directly
+			DEBUG1=0 #=DEBUG
+			DEBUG2=-0.1
+			DEBUG3=-0.2
+			IMPORTANT=1.5 #between warning and info
+			SUCCESS=1.3 #between warning and info
+			VERBOSE=0.9
+			VERBOSE1=0.9
+			VERBOSE2=0.8
+			VERBOSE3=0.7
+			QUIET=-9
+			DEBUG		= Logger::DEBUG # 0
+			INFO		= Logger::INFO # 1
+			WARN		= Logger::WARN # 2
+			ERROR		= Logger::ERROR # 3
+			FATAL		= Logger::FATAL # 4
+			UNKNOWN = Logger::UNKNOWN # 5
+		end
+
+		LOG_LEVELS=
+			{
+				'quiet' => Levels::QUIET,
+				'debug3' => Levels::DEBUG3,
+				'debug2' => Levels::DEBUG2,
+				'debug1' => Levels::DEBUG1,
+				'debug' => Levels::DEBUG, #0
+				'verbose' => Levels::VERBOSE,
+				'verbose1' => Levels::VERBOSE1,
+				'verbose2' => Levels::VERBOSE2,
+				'verbose3' => Levels::VERBOSE3,
+				'info' => Levels::INFO, #1
+				'success' => Levels::SUCCESS,
+				'important' => Levels::IMPORTANT,
+				'warn' => Levels::WARN, #2
+				'error' => Levels::ERROR, #3
+				'fatal' => Levels::FATAL, #4
+				'unknown' => Levels::UNKNOWN, #5
+			}
+
+		def log_levels
+			@levels ||= LOG_LEVELS.dup
+			@levels
+		end
+
+		attr_accessor :default, :active, :quiet
+
+		def initialize(*args, levels: {}, default: :info, active: :verbose, quiet: :warn, **kwds)
+			@default=default
+			@active=active
+			@quiet=quiet
+			super(*args, **kwds)
+			@default_formatter = Formatter.new
+			@level=severity_lvl(@default)
+			klass=self.singleton_class
+			levels=log_levels.merge!(levels)
+			levels.keys.each do |lvl, cst|
+				klass.define_method(lvl.to_sym) do |progname=nil, **opts, &block|
+					add(lvl.to_sym, nil, progname, **opts, &block)
+				end
+				klass.define_method("#{lvl}?".to_sym) do
+					@level <= cst
+				end
+			end
+		end
+
+		# log with given security. Also accepts 'true'
+		def add(severity, message = nil, progname = nil, default: @default, quiet: @quiet, callback: nil)
+			severity=severity(severity, default: default, quiet: quiet)
+			severity_lvl=severity_lvl(severity)
+			if @logdev.nil? or severity_lvl < @level
+				return true
+			end
+			if progname.nil?
+				progname = @progname
+			end
+			if message.nil?
+				if block_given?
+					message = yield
+				else
+					message = progname
+					progname = @progname
+				end
+			end
+			callback.call(message, progname, severity) if callback
+			@logdev.write(
+				format_message(format_severity(severity), Time.now, progname, message))
+			true
+		end
+
+		def severity(severity, default: @default, quiet: @quiet)
+			severity ||= UNKNOWN
+			severity=default if severity == true
+			severity=quiet if severity == false
+			severity
+		end
+
+		def severity_lvl(severity, **opts)
+			severity=severity(severity, **opts)
+			if severity.is_a?(Numeric)
+				return severity
+			else
+				sev=severity.to_s.downcase
+				if log_levels.key?(sev)
+					return log_levels[sev]
+				else
+					raise WrongLevel.new(severity)
+				end
+			end
+		end
+
+		def level=(severity)
+			@level = severity_lvl(severity)
+		end
+
+		# like level= but for clis, so we can pass a default if level=true
+		def cli_level(level, active: @active, quiet: @quiet)
+			level=active if level==true #for cli
+			level=quiet if level==false #for cli
+			self.level=level
+		end
+	end
+
+	class ColorLogger < MoreLogger #{{{1
+		CLI_COLORS_BASE={
+			# info: [:bold],
+			success: [:green, :bold],
+			important: [:blue, :bold],
+			warn: [:yellow, :bold],
+			error: [:red, :bold],
+			fatal: [:red, :bold]
+		}
+
+		CLI_COLORS={
+			mark: {lvl: :info, colors: :bold}
+		}
+
+		def cli_colors
+			return @cli_colors if defined?(@cli_colors)
+			@cli_colors={}
+			base_colors=CLI_COLORS_BASE
+			base_colors.each do |k,v|
+				r={colors: v}
+				@cli_colors[k.to_sym]=r
+			end
+			@cli_colors.merge!(CLI_COLORS)
+			@cli_colors
+			#mode => {lvl: lvl, colors: colors }
+		end
+
+		def add(severity, message = nil, progname = nil, color: [], raw: @raw, **args)
+			severity ||= UNKNOWN
+			severity=severity(severity)
+			color=[*color]
+			unless severity.is_a?(Numeric)
+				cli=cli_colors[severity.to_sym]
+				if cli
+					severity=cli[:lvl] if cli.key?(:lvl)
+					if !raw
+						color=[*cli[:colors]] + color
+					end
+				end
+			end
+			severity_lvl=severity_lvl(severity)
+
+			if @logdev.nil? or severity_lvl < @level
+				return true
+			end
+			if progname.nil?
+				progname = @progname
+			end
+			if message.nil?
+				if block_given?
+					message = yield
+				else
+					message = progname
+					progname = @progname
+				end
+			end
+			message = SimpleColor.color(message.to_s, *color)
+			super(severity_lvl, message, progname)
+		end
+
+		attr_accessor :raw
+
+		def initialize(*args, cli: {}, **kwds)
+			@raw=false
+			super(*args, **kwds)
+			klass=self.singleton_class
+			cli=cli_colors.merge!(cli)
+			(cli.keys - CLI_COLORS_BASE.keys).each do |lvl|
+				klass.define_method(lvl.to_sym) do |progname=nil, **opts, &block|
+					add(lvl, nil, progname, **opts, &block)
+				end
+			end
+			yield self if block_given?
+		end
+	end
+
+	# CLILogger {{{1
+	# 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 < ColorLogger
+		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 :'progname='
+		proxy_method :'datetime_format='
+
+		def add(severity, message = nil, progname = nil, **opts, &block) #:nodoc:
+			severity_lvl = severity_lvl(severity)
+			if @split_logs
+				unless severity_lvl >= @stderr_logger.level
+					super(severity,message,progname, **opts, &block)
+				end
+			else
+				super(severity,message,progname,**opts, &block)
+			end
+			@stderr_logger.add(severity,message,progname,**opts, &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: :auto, default_error: DEFAULT_ERROR_LEVEL, **kwds)
+			@stderr_logger = MoreLogger.new(error_device, default: default_error, **kwds)
+
+			super(log_device, **kwds)
+
+			log_device_tty	 = tty?(log_device)
+			error_device_tty = tty?(error_device)
+
+			@split_logs = log_device_tty && error_device_tty if split_log==:auto
+
+			self.level = Logger::Severity::INFO
+			@stderr_logger.level = @stderr_logger.default
+
+			self.formatter = BLANK_FORMAT if log_device_tty
+			@stderr_logger.formatter = BLANK_FORMAT if error_device_tty
+			yield self, @stderr_logger if block_given?
+		end
+
+		def level=(level)
+			super
+			#current_error_level = @stderr_logger.level
+			if (self.level > @stderr_logger.default) && @split_logs
+				@stderr_logger.level = self.level
+			end
+		end
+
+		def cli_level(*args)
+			super
+			if (self.level > @stderr_logger.default) && @split_logs
+				@stderr_logger.level = self.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
+
+		private def tty?(device_or_string)
+			return device_or_string.tty? if device_or_string.respond_to? :tty?
+			false
+		end
+
+		#log the action and execute it
+		#Severity is Logger:: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+		def log_and_do(*args, severity: 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
+			add(severity,msg)
+			if opts.empty?
+				definee.send(*args, &block)
+			else
+				definee.send(*args, **opts, &block)
+			end
+		end
+
+		private def toggle_log_level(toggle='debug')
+			@log_level_original = self.level unless @log_level_toggled
+			logger.level = if @log_level_toggled
+											 @log_level_original
+										 else
+											 log_levels.fetch(toggle)
+										 end
+			@log_level_toggled = !@log_level_toggled
+			@log_level = logger.level
+		end
+
+		#call logger.setup_toggle_trap('USR1') to change the log level to
+		#:debug when USR1 is received
+		def setup_toggle_trap(signal)
+			if signal
+				Signal.trap(signal) do
+					toggle_log_level
+				end
+			end
+		end
+
+	end
+
+	# CLILogging {{{1
+	# 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 CLILogging.class_variable_defined?(:@@logger)
+				@@logger = CLILogger.new
+				@@logger.progname=$0
+			end
+			@@logger
+		end
+
+		self.logger.progname||=$0
+
+		# 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 defined?(@log_level) && @log_level
+		end
+
+		alias logger= change_logger
+
+		#call CLILogging.setup_toggle_trap('USR1') to change the log level to
+		#:debug when USR1 is received
+		def self.setup_toggle_trap(signal)
+			logger.setup_toggle_trap(signal)
+		end
+
+		def log_and_do(*args)
+			logger.log_and_do(*args)
+		end
+
+		LOG_LEVELS=logger.log_levels
+
+		#Include this in place of CLILogging if you prefer to use
+		#info directly rather than logger.info
+		module Shortcuts #{{{
+			extend self
+			include CLILogging
+			LOG_LEVELS.each do |lvl, _cst|
+				define_method(lvl.to_sym) do |progname=nil, &block|
+					logger.send(lvl.to_sym, progname, &block)
+				end
+			end
+		end
+		#}}}
+	end #}}}
+end