loggability 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a7480c801b3343da84c0f66665a782bf058c9fe
-  data.tar.gz: 0762156f1674e35adc1b4bc79e12b9226fbc62a3
+  metadata.gz: ee8126c166b726262392de76f6c86784ddd8e0c3
+  data.tar.gz: 929fbd59dab8020f0baad40185a849d776e29dd2
 SHA512:
-  metadata.gz: 18801ec28bdef48b7b715ab735bf73bd606e7bd282702e137f72dd1240185a0c53e18d5374b3673b1275d2e3477ea61103d05eaccc6034513b6dc5d4adb499e8
-  data.tar.gz: 28438c4dd6ac7130f17a6adb3888dafa333b7e369c53f9a7dca9af33b1033bd856367d8529f0cfacede39023a9fdd83eb774640eff74d5e69eb64e516b37cd05
+  metadata.gz: bfcb674cbd0a108ab7508382a7a238a78f80c675d5ae4aae9cbad7ea8b31cc3d40b98536b7dabb23a8b37e73006721091de163e1dc680bb859482ee8ab5bca18
+  data.tar.gz: 140afe380f310616e4c1e0e0ec357d9f520bc381f4885c9db58cc9abae56ddeba8f6e63bf54c25509f19ac072b5114a5a299346b523ed05ae3cc3665ef31f655

data/History.rdoc

@@ -1,3 +1,12 @@
+== v0.11.0 [2014-04-02] Michael Granger <ged@FaerieMUD.org>
+
+Fix a bug when a log host is subclassed.
+
+- Inheriting a log host now registers the subclass as its own log host.
+- Add a gemspec-building task.
+- Eliminated the last vestiges of deprecated RSpec syntax.
+
+
 == v0.10.1 [2014-03-24] Michael Granger <ged@FaerieMUD.org>
 
 Bugfix: Raise an exception when something attempts to use a non-existant

data/Rakefile

@@ -8,6 +8,8 @@ rescue LoadError
 	abort "This Rakefile requires 'hoe' (gem install hoe)"
 end
 
+GEMSPEC = 'loggability.gemspec'
+
 Hoe.plugin :mercurial
 Hoe.plugin :signing
 Hoe.plugin :deveiate
@@ -60,3 +62,15 @@ if File.directory?( '.hg' )
 	end
 end
 
+task :gemspec => GEMSPEC
+file GEMSPEC => __FILE__ do |task|
+	spec = $hoespec.spec
+	spec.files.delete( '.gemtest' )
+	spec.version = "#{spec.version}.pre#{Time.now.strftime("%Y%m%d%H%M%S")}"
+	File.open( task.name, 'w' ) do |fh|
+		fh.write( spec.to_ruby )
+	end
+end
+
+task :default => :gemspec
+

data/lib/loggability.rb

@@ -9,10 +9,10 @@ require 'date'
 module Loggability
 
 	# Package version constant
-	VERSION = '0.10.1'
+	VERSION = '0.11.0'
 
 	# VCS revision
-	REVISION = %q$Revision: 24fd8762623d $
+	REVISION = %q$Revision: fa08d10cb3b6 $
 
 	# The key for the global logger (Loggability's own logger)
 	GLOBAL_KEY = :__global__

data/lib/loggability/logger.rb

@@ -150,6 +150,7 @@ class Loggability::Logger < ::Logger
 		self.level = if $DEBUG then :debug else :warn end
 		self.output_to( logdev, *args )
 
+		@created_from = caller( 3 ).first
 		@default_formatter = Loggability::Formatter.create( :default )
 	end
 
@@ -158,6 +159,11 @@ class Loggability::Logger < ::Logger
 	public
 	######
 
+	##
+	# The line that caused this logger to be created.
+	attr_reader :created_from
+
+
 	### Return a human-readable representation of the object suitable for debugging.
 	def inspect
 		dev = if self.logdev.respond_to?( :dev )

data/lib/loggability/loghost.rb

@@ -35,6 +35,13 @@ module Loggability::LogHost
 	end
 	alias_method :log=, :logger=
 
+
+	### Register subclasses of log hosts as their own log hosts.
+	def inherited( subclass )
+		super
+		Loggability.register_loghost( subclass )
+	end
+
 end # module Loggability::LogHost
 
 

data/spec/helpers.rb

@@ -101,7 +101,6 @@ end # module SpecHelpers
 
 ### Mock with RSpec
 RSpec.configure do |c|
-	c.treat_symbols_as_metadata_keys_with_true_values = true
 	c.run_all_when_everything_filtered = true
 	c.filter_run :focus
 	c.order = 'random'

data/spec/loggability/formatter/color_spec.rb

@@ -22,13 +22,14 @@ describe Loggability::Formatter::Color do
 		ENV['TERM'] = @original_term
 	end
 
-	before( :each ) do
-		@formatter = described_class.new
-	end
+
+	let( :formatter ) { described_class.new }
+
 
 	it "formats messages with ANSI color" do
-		@formatter.call( 'INFO', Time.at(1336286481), nil, "Foom." ).
-			should include( "-- \e[37mFoom.\e[0m\n" )
+		expect(
+			formatter.call( 'INFO', Time.at(1336286481), nil, "Foom." )
+		).to include( "-- \e[37mFoom.\e[0m\n" )
 	end
 
 end

data/spec/loggability/formatter/html_spec.rb

@@ -16,8 +16,9 @@ describe Loggability::Formatter::HTML do
 	subject { described_class.new }
 
 	it "formats messages as HTML" do
-		subject.call( 'INFO', Time.at(1336286481), nil, "Foom." ).
-			should =~ %r{<span class="log-message-text">Foom.</span>}i
+		expect(
+			subject.call( 'INFO', Time.at(1336286481), nil, "Foom." )
+		).to match( %r{<span class="log-message-text">Foom.</span>}i )
 	end
 
 	it "formats exceptions into useful messages" do
@@ -29,20 +30,22 @@ describe Loggability::Formatter::HTML do
 			msg = subject.call( 'INFO', Time.at(1336286481), nil, err )
 		end
 
-		msg.should =~ %r{<span class=\"log-exc\">ArgumentError</span>}i
-		msg.should =~ %r{<span class=\"log-exc-message\">invalid argument</span>}i
-		msg.should =~ %r{ from <span class=\"log-exc-firstframe\">}i
+		expect( msg ).to match( %r{<span class=\"log-exc\">ArgumentError</span>}i )
+		expect( msg ).to match( %r{<span class=\"log-exc-message\">invalid argument</span>}i )
+		expect( msg ).to match( %r{ from <span class=\"log-exc-firstframe\">}i )
 	end
 
 	it "formats regular objects into useful messages" do
-		subject.call( 'INFO', Time.at(1336286481), nil, Object.new ).
-			should =~ %r{<span class=\"log-message-text\">#&lt;Object:0x[[:xdigit:]]+&gt;</span>}
+		expect(
+			subject.call( 'INFO', Time.at(1336286481), nil, Object.new )
+		).to match( %r{<span class=\"log-message-text\">#&lt;Object:0x[[:xdigit:]]+&gt;</span>} )
 	end
 
 	it "escapes the 'progname' part of log messages" do
 		progname = "#<Class:0x007f9efa153d08>:0x7f9efa153c18"
-		subject.call( 'DEBUG', Time.at(1336286481), progname, Object.new ).
-			should =~ %r{#&lt;Class:0x0}
+		expect(
+			subject.call( 'DEBUG', Time.at(1336286481), progname, Object.new )
+		).to match( %r{#&lt;Class:0x0} )
 	end
 
 end

data/spec/loggability/logger_spec.rb

@@ -22,31 +22,29 @@ describe Loggability::Logger do
 	end
 
 
-	before( :each ) do
-		@logger = described_class.new
-	end
+	let( :logger ) { described_class.new }
 
 
 	it "has a less-verbose inspection format than that of its parent" do
-		expect( @logger.inspect ).to match( /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 )
+		regular_logger = ::Logger.new( $stderr )
+		newlogger = described_class.from_std_logger( regular_logger )
 		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.logdev.dev ).to be( regular_logger.instance_variable_get(:@logdev).dev )
+		expect( Loggability::LOG_LEVELS[newlogger.level] ).to eq( regular_logger.level )
 		expect( newlogger.formatter ).to be_a( Loggability::Formatter::Default )
 	end
 
 
 	it "writes to itself at :debug level if appended to" do
 		results = []
-		@logger.level = :debug
-		@logger.output_to( results )
-		@logger << "This is an appended message."
+		logger.level = :debug
+		logger.output_to( results )
+		logger << "This is an appended message."
 
 		expect( results.first ).to match( /debug.*this is an appended message/i )
 	end
@@ -54,58 +52,58 @@ describe Loggability::Logger do
 
 	it "supports #write so it can be used with Rack::CommonLogger" do
 		results = []
-		@logger.level = :debug
-		@logger.output_to( results )
-		@logger.write( "This is a written message." )
+		logger.level = :debug
+		logger.output_to( results )
+		logger.write( "This is a written message." )
 
 		expect( results.first ).to match( /info.*this is a written 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 )
+		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
+		settings = logger.settings
 
-		@logger.level = :fatal
-		@logger.formatter = Loggability::Formatter.create( :html )
-		@logger.output_to( [] )
+		logger.level = :fatal
+		logger.formatter = Loggability::Formatter.create( :html )
+		logger.output_to( [] )
 
-		@logger.restore_settings( settings )
+		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] )
+		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 = logger.settings
 		settings.delete( :level )
 
-		@logger.level = :fatal
-		@logger.formatter = Loggability::Formatter.create( :html )
-		@logger.output_to( [] )
+		logger.level = :fatal
+		logger.formatter = Loggability::Formatter.create( :html )
+		logger.output_to( [] )
 
-		@logger.restore_settings( settings )
+		logger.restore_settings( settings )
 
-		expect( @logger.level ).to be( :fatal )
-		expect( @logger.formatter ).to be( settings[:formatter] )
-		expect( @logger.logdev ).to be( settings[:logdev] )
+		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
-			expect( @logger.level ).to eq( :warn )
+			expect( logger.level ).to eq( :warn )
 		end
 
 		it "defaults to :debug level when $DEBUG is true" do
@@ -120,18 +118,18 @@ describe Loggability::Logger do
 		it "allows its levels to be set with integers like Logger" do
 			newlevel = Logger::DEBUG
 			$stderr.puts "Setting newlevel to %p" % [ newlevel ]
-			@logger.level = newlevel
-			expect( @logger.level ).to eq( :debug )
+			logger.level = newlevel
+			expect( logger.level ).to eq( :debug )
 		end
 
 		it "allows its levels to be set with Symbolic level names" do
-			@logger.level = :info
-			expect( @logger.level ).to eq( :info )
+			logger.level = :info
+			expect( logger.level ).to eq( :info )
 		end
 
 		it "allows its levels to be set with Stringish level names" do
-			@logger.level = 'fatal'
-			expect( @logger.level ).to eq( :fatal )
+			logger.level = 'fatal'
+			expect( logger.level ).to eq( :fatal )
 		end
 
 	end
@@ -140,50 +138,50 @@ describe Loggability::Logger do
 	describe "log device API" do
 
 		it "logs to STDERR by default" do
-			expect( @logger.logdev.dev ).to 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 )
-			expect( @logger.logdev.dev ).to be_a( File )
+			logger.output_to( tmpfile.path )
+			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 )
-			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 )
+			logger.output_to( tmpfile.path, 5, 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 )
-			expect( @logger.logdev ).to be_a( Loggability::Logger::AppendingLogDevice )
-			@logger.level = :debug
-			@logger.info( "Something happened." )
+			logger.output_to( logmessages )
+			expect( logger.logdev ).to be_a( Loggability::Logger::AppendingLogDevice )
+			logger.level = :debug
+			logger.info( "Something happened." )
 			expect( logmessages.size ).to eq(  1  )
 			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 )
+			logger.output_to( tmpfile.path, 5, 125000 )
 
-			original_logdev = @logger.logdev
-			@logger.output_to( original_logdev )
+			original_logdev = logger.logdev
+			logger.output_to( original_logdev )
 
-			expect( @logger.logdev ).to be( 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 )
+			logger.output_to( log_array )
+			logger.output_to( logger.logdev )
 
-			expect( @logger.logdev.target ).to be( log_array )
+			expect( logger.logdev.target ).to be( log_array )
 		end
 
 	end
@@ -192,36 +190,36 @@ describe Loggability::Logger do
 	describe "formatter API" do
 
 		it "logs with the default formatter by default" do
-			expect( @logger.formatter ).to 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 )
-			expect( @logger.formatter ).to be_a( Loggability::Formatter::Default )
+			logger.format_as( :default )
+			expect( logger.formatter ).to be_a( Loggability::Formatter::Default )
 		end
 
 		it "can be told to use a block as a formatter" do
-			@logger.format_with do |severity, datetime, progname, msg|
+			logger.format_with do |severity, datetime, progname, msg|
 				original_formatter.call(severity, datetime, progname, msg.dump)
 			end
 
-			expect( @logger.formatter ).to 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 )
-			expect( @logger.formatter ).to be_a( Loggability::Formatter::HTML )
+			logger.format_as( :html )
+			expect( logger.formatter ).to 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."
+			logger.output_to( output )
+			logger.level = :debug
+			logger.formatter = ::Logger::Formatter.new
+			logger.debug "This should work."
 
-			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/)
+			expected_format = /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( expected_format )
 		end
 
 	end
@@ -231,24 +229,26 @@ describe Loggability::Logger do
 
 		it "can create a proxy object that will log with the argument object as the 'progname'" do
 			messages = []
-			@logger.output_to( messages )
-			@logger.level = :debug
+			logger.output_to( messages )
+			logger.level = :debug
 
 			obj = Object.new
-			proxy = @logger.proxy_for( obj )
+			proxy = logger.proxy_for( obj )
 			proxy.debug( "A debug message." )
 			proxy.info( "An info message." )
 			proxy.warn( "A warn message." )
 			proxy.error( "An error message." )
 			proxy.fatal( "A fatal message." )
 
-			expect( messages.first ).to match(/DEBUG \{Object:0x[[:xdigit:]]+\} -- A debug message.\n/i)
+			expected_format = /DEBUG \{Object:0x[[:xdigit:]]+\} -- A debug message.\n/i
+			expect( messages.first ).to match( expected_format )
 		end
 
 		it "has a terse inspection format" do
 			object = Object.new
-			@logger.proxy_for( object ).inspect.
-				should =~ /ObjectNameProxy.* for Object/
+			expect(
+				logger.proxy_for( object ).inspect
+			).to match( /ObjectNameProxy.* for Object/ )
 		end
 
 	end

data/spec/loggability/override_spec.rb

@@ -55,7 +55,7 @@ describe Loggability::Override do
 		end
 		loghost.logger.debug "This shouldn't either."
 
-		expect( log.size ).to eq(  1  )
+		expect( log.size ).to eq( 1 )
 	end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loggability
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Michael Granger
@@ -30,7 +30,7 @@ cert_chain:
   c7ZKPJcWBv0sm81+FCZXNACn2f9jfF8OQinxVs0O052KbGuEQaaiGIYeuuwQE2q6
   ggcrPfcYeTwWlfZPu2LrBg==
   -----END CERTIFICATE-----
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe-mercurial
@@ -47,47 +47,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.4.0
 - !ruby/object:Gem::Dependency
-  name: hoe-highline
+  name: hoe-deveiate
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: hoe-highline
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: hoe-deveiate
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: hoe-bundler
   requirement: !ruby/object:Gem::Requirement
@@ -136,14 +136,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.11'
 description: "A composable logging system built on the standard Logger library.\n\nYou
   can add Loggability to large libraries and systems, then hook everything\nup later
   when you know where you want logs to be written, at what level of\nseverity, and
@@ -211,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: loggability
+rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4