loggability 0.7.0 → 0.8.0.pre.65

data/spec/loggability/formatter/color_spec.rb

@@ -1,14 +1,11 @@
 # -*- rspec -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-}
+require_relative '../../helpers'
 
 require 'tempfile'
 require 'rspec'
-require 'spec/lib/helpers'
+
 require 'loggability/logger'
 require 'loggability/formatter'
 require 'loggability/formatter/color'

data/spec/loggability/formatter/html_spec.rb

@@ -1,14 +1,11 @@
 # -*- rspec -*-
+#encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-}
+require_relative '../../helpers'
 
 require 'tempfile'
 require 'rspec'
-require 'spec/lib/helpers'
+
 require 'loggability/logger'
 require 'loggability/formatter'
 require 'loggability/formatter/html'

data/spec/loggability/formatter_spec.rb

@@ -1,14 +1,10 @@
 # -*- rspec -*-
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-}
+require_relative '../helpers'
 
 require 'tempfile'
 require 'rspec'
-require 'spec/lib/helpers'
+
 require 'loggability/logger'
 require 'loggability/formatter'
 require 'loggability/formatter/default'
@@ -18,8 +14,8 @@ describe Loggability::Formatter do
 
 	it "formats messages with the pattern it's constructed with" do
 		formatter = Loggability::Formatter.new( '[%5$s] %7$s' )
-		formatter.call( 'INFO', Time.at(1336286481), nil, 'Foom.' ).should =~
-			/\[INFO\] Foom./i
+		result = formatter.call( 'INFO', Time.at(1336286481), nil, 'Foom.' )
+		expect( result ).to match(/\[INFO\] Foom./i)
 	end
 
 	it "formats exceptions into useful messages" do
@@ -32,13 +28,14 @@ describe Loggability::Formatter do
 			msg = formatter.call( 'INFO', Time.at(1336286481), nil, err )
 		end
 
-		msg.should =~ /\[INFO\] ArgumentError: invalid argument/i
+		expect( msg ).to match(/\[INFO\] ArgumentError: invalid argument/i)
 	end
 
 	it "formats regular objects into useful messages" do
 		formatter = Loggability::Formatter.new( '[%5$s] %7$s' )
-		formatter.call( 'INFO', Time.at(1336286481), nil, Object.new ).should =~
-			/\[INFO\] #<Object:0x[[:xdigit:]]+>/i
+		result = formatter.call( 'INFO', Time.at(1336286481), nil, Object.new )
+
+		expect( result ).to match(/\[INFO\] #<Object:0x[[:xdigit:]]+>/i)
 	end
 
 end

data/spec/loggability/logger_spec.rb

@@ -1,14 +1,10 @@
 # -*- rspec -*-
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-}
+require_relative '../helpers'
 
 require 'tempfile'
 require 'rspec'
-require 'spec/lib/helpers'
+
 require 'loggability/logger'
 require 'loggability/formatter'
 require 'loggability/formatter/default'
@@ -32,17 +28,17 @@ describe Loggability::Logger do
 
 
 	it "has a less-verbose inspection format than that of its parent" do
-		@logger.inspect.should =~ /severity: \S+ formatter: \S+ outputting to: \S+/
+		expect( @logger.inspect ).to match( /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 )
+		expect( newlogger ).to be_a( Loggability::Logger )
+		expect( newlogger.logdev.dev ).to be( logger.instance_variable_get(:@logdev).dev )
+		expect( Loggability::LOG_LEVELS[newlogger.level] ).to eq( logger.level )
+		expect( newlogger.formatter ).to be_a( Loggability::Formatter::Default )
 	end
 
 
@@ -52,20 +48,60 @@ describe Loggability::Logger do
 		@logger.output_to( results )
 		@logger << "This is an appended message."
 
-		results.first.should =~ /debug.*this is an appended message/i
+		expect( results.first ).to match( /debug.*this is an appended message/i )
+	end
+
+
+	it "can return a Hash of its current settings" do
+		expect( @logger.settings ).to be_a( Hash )
+		expect( @logger.settings ).to include( :level, :formatter, :logdev )
+		expect( @logger.settings[:level] ).to eq( @logger.level )
+		expect( @logger.settings[:formatter] ).to eq( @logger.formatter )
+		expect( @logger.settings[:logdev] ).to eq( @logger.logdev )
+	end
+
+
+	it "can restore its settings from a Hash" do
+		settings = @logger.settings
+
+		@logger.level = :fatal
+		@logger.formatter = Loggability::Formatter.create( :html )
+		@logger.output_to( [] )
+
+		@logger.restore_settings( settings )
+
+		expect( @logger.level ).to be( settings[:level] )
+		expect( @logger.formatter ).to be( settings[:formatter] )
+		expect( @logger.logdev ).to be( settings[:logdev] )
+	end
+
+
+	it "ignores missing keys when restoring its settings from a Hash" do
+		settings = @logger.settings
+		settings.delete( :level )
+
+		@logger.level = :fatal
+		@logger.formatter = Loggability::Formatter.create( :html )
+		@logger.output_to( [] )
+
+		@logger.restore_settings( settings )
+
+		expect( @logger.level ).to be( :fatal )
+		expect( @logger.formatter ).to be( settings[:formatter] )
+		expect( @logger.logdev ).to be( settings[:logdev] )
 	end
 
 
 	describe "severity level API" do
 
 		it "defaults to :warn level" do
-			@logger.level.should == :warn
+			expect( @logger.level ).to eq( :warn )
 		end
 
 		it "defaults to :debug level when $DEBUG is true" do
 			begin
 				$DEBUG = true
-				described_class.new.level.should == :debug
+				expect( described_class.new.level ).to eq( :debug )
 			ensure
 				$DEBUG = false
 			end
@@ -75,17 +111,17 @@ describe Loggability::Logger do
 			newlevel = Logger::DEBUG
 			$stderr.puts "Setting newlevel to %p" % [ newlevel ]
 			@logger.level = newlevel
-			@logger.level.should == :debug
+			expect( @logger.level ).to eq( :debug )
 		end
 
 		it "allows its levels to be set with Symbolic level names" do
 			@logger.level = :info
-			@logger.level.should == :info
+			expect( @logger.level ).to eq( :info )
 		end
 
 		it "allows its levels to be set with Stringish level names" do
 			@logger.level = 'fatal'
-			@logger.level.should == :fatal
+			expect( @logger.level ).to eq( :fatal )
 		end
 
 	end
@@ -94,32 +130,50 @@ describe Loggability::Logger do
 	describe "log device API" do
 
 		it "logs to STDERR by default" do
-			@logger.logdev.dev.should be( $stderr )
+			expect( @logger.logdev.dev ).to be( $stderr )
 		end
 
 		it "can be told to log to a file" do
 			tmpfile = Tempfile.new( 'loggability-device-spec' )
 			@logger.output_to( tmpfile.path )
-			@logger.logdev.dev.should be_a( File )
+			expect( @logger.logdev.dev ).to be_a( File )
 		end
 
 		it "supports log-rotation arguments for logfiles" do
 			tmpfile = Tempfile.new( 'loggability-device-spec' )
 			@logger.output_to( tmpfile.path, 5, 125000 )
-			@logger.logdev.dev.should be_a( File )
-			@logger.logdev.filename.should == tmpfile.path
-			@logger.logdev.instance_variable_get( :@shift_age ).should == 5
-			@logger.logdev.instance_variable_get( :@shift_size ).should == 125000
+			expect( @logger.logdev.dev ).to be_a( File )
+			expect( @logger.logdev.filename ).to eq( tmpfile.path )
+			expect( @logger.logdev.instance_variable_get(:@shift_age) ).to eq( 5 )
+			expect( @logger.logdev.instance_variable_get(:@shift_size) ).to eq( 125000 )
 		end
 
 		it "can be told to log to an Array" do
 			logmessages = []
 			@logger.output_to( logmessages )
-			@logger.logdev.should be_a( Loggability::Logger::AppendingLogDevice )
+			expect( @logger.logdev ).to be_a( Loggability::Logger::AppendingLogDevice )
 			@logger.level = :debug
 			@logger.info( "Something happened." )
-			logmessages.should have( 1 ).member
-			logmessages.first.should =~ /something happened/i
+			expect( logmessages ).to have( 1 ).member
+			expect( logmessages.first ).to match( /something happened/i )
+		end
+
+		it "doesn't re-wrap a Logger::LogDevice" do
+			tmpfile = Tempfile.new( 'loggability-device-spec' )
+			@logger.output_to( tmpfile.path, 5, 125000 )
+
+			original_logdev = @logger.logdev
+			@logger.output_to( original_logdev )
+
+			expect( @logger.logdev ).to be( original_logdev )
+		end
+
+		it "doesn't re-wrap an AppendingLogDevice" do
+			log_array = []
+			@logger.output_to( log_array )
+			@logger.output_to( @logger.logdev )
+
+			expect( @logger.logdev.target ).to be( log_array )
 		end
 
 	end
@@ -128,12 +182,12 @@ describe Loggability::Logger do
 	describe "formatter API" do
 
 		it "logs with the default formatter by default" do
-			@logger.formatter.should be_a( Loggability::Formatter::Default )
+			expect( @logger.formatter ).to be_a( Loggability::Formatter::Default )
 		end
 
 		it "can be told to use the default formatter explicitly" do
 			@logger.format_as( :default )
-			@logger.formatter.should be_a( Loggability::Formatter::Default )
+			expect( @logger.formatter ).to be_a( Loggability::Formatter::Default )
 		end
 
 		it "can be told to use a block as a formatter" do
@@ -141,12 +195,12 @@ describe Loggability::Logger do
 				original_formatter.call(severity, datetime, progname, msg.dump)
 			end
 
-			@logger.formatter.should be_a( Proc )
+			expect( @logger.formatter ).to be_a( Proc )
 		end
 
 		it "can be told to use the HTML formatter" do
 			@logger.format_as( :html )
-			@logger.formatter.should be_a( Loggability::Formatter::HTML )
+			expect( @logger.formatter ).to be_a( Loggability::Formatter::HTML )
 		end
 
 		it "supports formatting with ::Logger::Formatter, too" do
@@ -155,7 +209,9 @@ describe Loggability::Logger do
 			@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/
+
+			expect( output.first ).
+				to match(/D, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d.\d+ #\d+\] DEBUG -- : This should work.\n/)
 		end
 
 	end
@@ -176,7 +232,7 @@ describe Loggability::Logger do
 			proxy.error( "An error message." )
 			proxy.fatal( "A fatal message." )
 
-			messages.first.should =~ /DEBUG \{Object:0x[[:xdigit:]]+\} -- A debug message.\n/i
+			expect( messages.first ).to match(/DEBUG \{Object:0x[[:xdigit:]]+\} -- A debug message.\n/i)
 		end
 
 		it "has a terse inspection format" do

data/spec/loggability/override_spec.rb

@@ -0,0 +1,134 @@
+# -*- rspec -*-
+
+require_relative '../helpers'
+
+require 'tempfile'
+require 'rspec'
+
+require 'loggability/logger'
+require 'loggability/override'
+
+
+describe Loggability::Override do
+
+	after( :each ) do
+		Loggability.clear_loghosts
+	end
+
+
+	let!( :override ) { described_class.new }
+	let!( :loghost ) do
+		Class.new do
+			extend Loggability
+			log_as :testing
+		end
+	end
+
+
+	it "doesn't override anything by default" do
+		previous_level = Loggability[ loghost ].level
+		override.call do
+			expect( Loggability[ loghost ].level ).to be( previous_level )
+		end
+	end
+
+
+	it "raises an error when #called re-entrantly" do
+		override.call do
+			expect { override.call {} }.to raise_error( LocalJumpError )
+		end
+	end
+
+
+	it "can mutate itself into a variant that modifies the logging level" do
+		log = []
+
+		Loggability.level = :fatal
+		Loggability.output_to( log )
+		Loggability.format_with( :default )
+
+		level_override = override.with_level( :debug )
+
+		loghost.logger.debug "This shouldn't show up."
+		level_override.call do
+			loghost.logger.debug "But this should."
+		end
+		loghost.logger.debug "This shouldn't either."
+
+		expect( log ).to have( 1 ).log_entry
+	end
+
+
+	it "has a constructor delegator for its level mutator" do
+		override = described_class.with_level( :debug )
+		expect( override.settings ).to eq({ level: :debug })
+	end
+
+
+	it "can mutate itself into a variant that modifies where output goes" do
+		original_destination = []
+		new_destination      = []
+		output_override      = override.outputting_to( new_destination )
+
+		Loggability.level = :debug
+		Loggability.output_to( original_destination )
+		Loggability.format_with( :default )
+
+		loghost.logger.debug "This should be output to the original destination"
+		output_override.call do
+			loghost.logger.debug "This should be output to the overridden destination"
+		end
+		loghost.logger.debug "This should be output to the original destination"
+
+		expect( original_destination ).to have( 2 ).log_entries
+		expect( new_destination ).to have( 1 ).log_entry
+	end
+
+
+	it "has a constructor delegator for its output mutator" do
+		log = []
+		override = described_class.outputting_to( log )
+		expect( override.settings ).to eq({ logdev: log })
+	end
+
+
+	it "can mutate itself into a variant that formats output differently" do
+		log = []
+		Loggability.level = :debug
+		Loggability.output_to( log )
+		Loggability.format_with( :default )
+
+		format_override = override.formatted_with( :html )
+
+		loghost.logger.debug "This should be in the default format"
+		format_override.call do
+			loghost.logger.debug "This should be in the color format"
+		end
+		loghost.logger.debug "This should be in the default format again"
+
+		html_log = log.grep( /<div/ )
+
+		expect( log ).to have( 3 ).entries
+		expect( html_log ).to have( 1 ).entry
+	end
+
+
+	it "has a constructor delegator for its format mutator" do
+		override = described_class.formatted_with( :color )
+		expect( override.settings ).to eq({ formatter: :color })
+	end
+
+
+	it "has additive mutators" do
+		override = described_class.
+			formatted_with( :color ).
+			with_level( :debug ).
+			outputting_to( $stdout )
+
+		expect( override.settings[:formatter] ).to be( :color )
+		expect( override.settings[:logdev] ).to be( $stdout )
+		expect( override.settings[:level] ).to be( :debug )
+	end
+
+end
+