Add some conversion-convenience code.

Auto-convert Logger instances into Loggability::Logger instances with the same
device if assigned directly, etc.

lib/loggability.rb

@@ -61,6 +61,15 @@ def self::version_string( include_buildnum=false )
 	end
 
 
+	### Cast the given +device+ to a Loggability::Logger, if possible, and return it. If
+	### it can't be converted, raises a ArgumentError.
+	def self::Logger( device )
+		return device if device.is_a?( Loggability::Logger )
+		return Loggability::Logger.from_std_logger( device ) if device.is_a?( ::Logger )
+		return Loggability::Logger.new( device )
+	end
+
+
 	### Register the specified +host+ as a log host. It should already have been extended
 	### with LogHostMethods.
 	def self::register_loghost( host )
@@ -188,13 +197,20 @@ module LogHost
 		attr_accessor :default_logger
 
 		# The logger that's currently in effect
-		attr_accessor :logger
+		attr_reader :logger
 		alias_method :log, :logger
-		alias_method :log=, :logger=
 
 		# The key associated with the logger for this host
 		attr_accessor :log_host_key
 
+
+		### Set the logger associated with the LogHost to +newlogger+. If +newlogger+ isn't a
+		### Loggability::Logger, it will be converted to one.
+		def logger=( newlogger )
+			@logger = Loggability::Logger( newlogger )
+		end
+		alias_method :log=, :logger=
+
 	end # module LogHost
 
 

lib/loggability/logger.rb

@@ -125,10 +125,31 @@ def make_progname( object )
 	end # class ObjectNameProxy
 
 
+	### Return an equivalent Loggability::Logger object for the given +logger+.
+	def self::from_std_logger( logger )
+		device = logger.instance_variable_get( :@logdev ) or
+			raise ArgumentError, "%p doesn't appear to be a Logger (no @logdev)" % [ logger ]
+
+		newlogger = self.new( device.dev )
+
+		newlogger.level     = logger.level
+		newlogger.formatter = logger.formatter
+
+		return newlogger
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
 	### Create a new Logger wrapper that will output to the specified +logdev+.
 	def initialize( logdev=DEFAULT_DEVICE, *args )
-		super
+		super( nil )
+
 		self.level = if $DEBUG then :debug else :warn end
+		self.output_to( logdev, *args )
+
 		@default_formatter = Loggability::Formatter.create( :default )
 	end
 
@@ -189,7 +210,7 @@ def level=( newlevel )
 	### set up logging to any object that responds to #<<.
 	def output_to( target, *args )
 		if target.respond_to?( :write ) || target.is_a?( String )
-			opts = { :shift_age => args.shift, :shift_size => args.shift }
+			opts = { :shift_age => args.shift || 0, :shift_size => args.shift || 1048576 }
 			self.logdev = Logger::LogDevice.new( target, opts )
 		elsif target.respond_to?( :<< )
 			self.logdev = AppendingLogDevice.new( target )

spec/loggability/logger_spec.rb

@@ -35,6 +35,17 @@
 		@logger.inspect.should =~ /severity: \S+ formatter: \S+ outputting to: \S+/
 	end
 
+
+	it "provides an upgrade constructor for regular Logger objects" do
+		logger = ::Logger.new( $stderr )
+		newlogger = described_class.from_std_logger( logger )
+		newlogger.should be_a( Loggability::Logger )
+		newlogger.logdev.dev.should be( logger.instance_variable_get(:@logdev).dev )
+		Loggability::LOG_LEVELS[ newlogger.level ].should == logger.level
+		newlogger.formatter.should be_a( Loggability::Formatter::Default )
+	end
+
+
 	describe "severity level API" do
 
 		it "defaults to :warn level" do
@@ -128,6 +139,15 @@
 			@logger.formatter.should be_a( Loggability::Formatter::HTML )
 		end
 
+		it "supports formatting with ::Logger::Formatter, too" do
+			output = []
+			@logger.output_to( output )
+			@logger.level = :debug
+			@logger.formatter = ::Logger::Formatter.new
+			@logger.debug "This should work."
+			output.first.should =~ /D, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d.\d+ #\d+\] DEBUG -- : This should work.\n/
+		end
+
 	end
 
 

spec/loggability_spec.rb

@@ -26,6 +26,7 @@
 		described_class.log_hosts.should include( Loggability::GLOBAL_KEY => Loggability )
 	end
 
+
 	describe "version methods" do
 		it "returns a version string if asked" do
 			described_class.version_string.should =~ /\w+ [\d.]+/
@@ -84,6 +85,17 @@
 			Loggability[ subclass ].should be( origin.logger )
 		end
 
+		it "wraps Logger instances assigned as its logger in a Loggability::Logger" do
+			@class.log_as( :testing )
+
+			logger = ::Logger.new( $stderr )
+
+			@class.logger = logger
+			@class.logger.should be_a( Loggability::Logger )
+
+			@class.log.debug "This shouldn't raise."
+		end
+
 	end