gem_logger 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTIzNzQ0NzlhNDdlMjkzMDk5NDM1ZTBjZWU3NmYxN2ZmMzhmNWQ1OQ==
+  data.tar.gz: !binary |-
+    MmFkOTczODI3NGFjZTczNWEzOTk2OTU4N2Q4MWY2ZDdmYTgyYTBkMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YmU1OWJkMTFmMTg5MWExNDYwMzJjOWQ2OWM4N2ViZTI1ZDU3ZDQyM2MzOTc4
+    ZDBlZGVjODBhMGIwNTk3MmM0NzFkNGNjMTZlNTcxMGJmMTBkZWU4MTI0ZjYy
+    OTE1NDBlYzRiNjZhYmJiZWU2MDA0MmYxY2U2OGVjZjgwZjU1MzA=
+  data.tar.gz: !binary |-
+    MzYzZmMxYzAzYTZjOTRmNjUyOWI4YWY5NGRjYjZiNDhiNzM2OTdhMDAwNzdk
+    NzI4ZDhkZGY5OTBhZWY2MDI4ZjdlY2E2MzNiNzNlYzFhYzc0ZjljM2YxZGIx
+    NWEzODBlZDcxY2FkMTQ5MzQxNTlhNjdlYjc4Njc1NTI1ODMwMGY=

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+  
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gem_logger.gemspec
+gemspec
+
+# so we can test GemLogger.logger_concern
+gem "lumber", :require => false
+
+# for code coverage during travis-ci test runs
+gem 'coveralls', :require => false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt Conway
+
+MIT License
+
+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,23 @@
+[![Build Status](https://secure.travis-ci.org/wr0ngway/gem_logger.png)](http://travis-ci.org/wr0ngway/gem_logger)
+[![Coverage Status](https://coveralls.io/repos/wr0ngway/gem_logger/badge.png?branch=master)](https://coveralls.io/r/wr0ngway/gem_logger?branch=master)
+
+# GemLogger
+
+Allows classes/modules in gems to have logger class/instance methods with a pluggable Logger implementation
+
+## Usage
+
+Include the GemLogger::Logger concern into the classes that need to be able to log.  By default, it will use the standard Ruby logger, if you need a different logger, then configure GemLogger like:
+
+    GemLogger.configure do |config|
+    
+      # The default logger instance to use
+      # (optional, defaults to Logger.new) 
+      config.default_logger = CustomLogger.new
+    
+      # module to include when GemLogger::Logger is included
+      # (optional, defaults to GemLogger::BasicLogger) 
+      config.logger_concern = SomeModule
+    
+    end
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs.push 'test'
+end
+
+task :default => :test
+
+task :console do
+  Bundler.require
+  require "gem_logger"
+  ARGV.clear
+  require "irb"
+  IRB.start
+end

data/gem_logger.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gem_logger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gem_logger"
+  spec.version       = GemLogger::VERSION
+  spec.authors       = ["Matt Conway"]
+  spec.email         = ["matt@conwaysplace.com"]
+  spec.description   = %q{Allows classes/modules in gems to have logger class/instance methods with a pluggable Logger implementation}
+  spec.summary       = %q{Allows classes/modules in gems to have logger class/instance methods with a pluggable Logger implementation}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest_should"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "faker"
+
+  spec.add_dependency "activesupport"
+end

data/lib/gem_logger/basic_logger.rb

@@ -0,0 +1,16 @@
+module GemLogger
+  
+  # Default support for built in ruby logger
+  module BasicLogger
+    
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def logger
+        GemLogger::default_logger
+      end
+    end
+    
+  end
+  
+end

data/lib/gem_logger/logger_support.rb

@@ -0,0 +1,51 @@
+module GemLogger
+  module LoggerSupport
+    
+    extend ActiveSupport::Concern
+  
+    included do
+      # A guard to prevent misuse, may just want a log message instead of a hard fail
+      if self.class == Module && ! self.singleton_class.included_modules.include?(ActiveSupport::Concern)
+        raise ArgumentError, "module that includes #{self.name} must be an ActiveSupport::Concern"
+      end
+      
+      include GemLogger.logger_concern
+      
+      delegate :logger, :log_exception, :log_warning, :log_message, :to => "self.class"      
+    end
+        
+    module ClassMethods
+
+      def log_exception(exception, opts={})
+        logger.error("Exception #{generate_message(exception, opts)}")
+      end
+
+      def log_warning(exception, opts={})
+        logger.warn("Warning #{generate_message(exception, opts)}")
+      end
+
+      def log_message(group, message, opts={})
+        log_exception({:error_class   => group,
+                       :error_message => message },
+                      opts)
+      end
+
+      def log_encode(str)
+        str.encode('UTF-8', :invalid => :replace, :undef => :replace, :replace => '')
+      end
+
+      def generate_message(exception, opts)
+        class_name = self.name
+        method_name = caller.first.gsub(/.*`(.*)'$/, '\1') rescue nil
+        opts = {:controller => class_name, :action => method_name}.merge(opts)
+
+        message_prefix = opts[:message_prefix] || ''
+        message_prefix += ' ' unless message_prefix.strip.size == 0
+
+        "#{log_encode(message_prefix)}#{log_encode(exception.inspect)}, #{log_encode(opts.inspect)}:\n#{exception.backtrace.collect {|x| log_encode(x)}.join("\n") rescue 'no backtrace'}"
+      end
+      
+    end
+
+  end
+end

data/lib/gem_logger/version.rb

@@ -0,0 +1,3 @@
+module GemLogger
+  VERSION = "0.1.0"
+end

data/lib/gem_logger.rb

@@ -0,0 +1,52 @@
+require "gem_logger/version"
+
+require 'logger'
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
+require "gem_logger/basic_logger"
+require "gem_logger/logger_support"
+
+# To configure gem_logger, add something like the
+# following to an initializer (defaults shown):
+#
+#    GemLogger.configure do |config|
+#
+#      # The default logger instance to use
+#      # (optional, defaults to Logger.new) 
+#      config.default_logger = CustomLogger.new
+#
+#      # module to include when GemLogger::LoggerSupport is included
+#      # (optional, defaults to GemLogger::BasicLogger) 
+#      config.logger_concern = SomeModule
+#
+#    end
+#
+module GemLogger
+  
+  # Allows configuring via class accessors
+  class << self
+    # The logger concern (ActiveSupport::Concern) to include when clients include GemLogger::Logger
+    # The module needs to cause a class level "logger" method (returning the logger instance) to be deSupportfined on the client
+    attr_accessor :logger_concern
+  end
+  
+  # default values
+  self.logger_concern = GemLogger::BasicLogger
+
+  # The default_logger to use with GemLogger::BasicLogger
+  def self.default_logger
+    @default_logger ||= ::Logger.new(STDOUT)
+  end
+
+  # Set the default_logger to use with GemLogger::BasicLogger
+  def self.default_logger=(default_logger)
+    @default_logger = default_logger
+  end
+  
+  # Allows configuring via class accessors
+  def self.configure
+    yield self
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'minitest/autorun'
+require 'minitest/should'
+require "minitest/reporters"
+
+reporter = ENV['REPORTER']
+reporter = case reporter
+  when 'none' then nil
+  when 'spec' then MiniTest::Reporters::SpecReporter.new
+  when 'progress' then MiniTest::Reporters::ProgressReporter.new
+  else MiniTest::Reporters::DefaultReporter.new
+end
+MiniTest::Reporters.use!(reporter) if reporter
+
+require 'gem_logger'
+
+# Allow triggering single tests when running from rubymine
+# reopen the installed runner so we don't step on runner customizations
+class << MiniTest::Unit.runner
+  # Rubymine sends --name=/\Atest\: <context> should <should>\./
+  # Minitest runs each context as a suite
+  # Minitest filters methods by matching against: <suite>#test_0001_<should>
+  # Nested contexts are separted by spaces in rubymine, but ::s in minitest
+  
+  def _run_suites(suites, type)
+    if options[:filter]
+      if options[:filter] =~ /\/\\Atest\\: (.*) should (.*)\\\.\//
+        context_filter = $1
+        should_filter = $2
+        should_filter.strip!
+        should_filter.gsub!(" ", "_")
+        should_filter.gsub!(/\W/, "")
+        context_filter = context_filter.gsub(" ", "((::)| )")
+        options[:filter] = "/\\A#{context_filter}(Test)?#test(_\\d+)?_should_#{should_filter}\\Z/"
+      end
+    end
+    
+    super
+  end
+  
+  # Prevent "Empty test suite" verbosity when running in rubymine
+  def _run_suite(suite, type)
+    
+    filter = options[:filter] || '/./'
+    filter = Regexp.new $1 if filter =~ /\/(.*)\//    
+    all_test_methods = suite.send "#{type}_methods"
+    filtered_test_methods = all_test_methods.find_all { |m|
+      filter === m || filter === "#{suite}##{m}"
+    }
+    
+    if filtered_test_methods.size > 0    
+      super
+    else
+      [0, 0]
+    end
+  end
+end

data/test/unit/gem_logger/basic_logger_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+module GemLogger
+  class BasicLoggerTest < Minitest::Should::TestCase
+    
+    context "BasicLogger" do
+      
+      should "define a logger class method" do
+        class MyClass
+          include GemLogger::BasicLogger
+        end
+        assert MyClass.respond_to?(:logger)
+      end
+      
+    end
+    
+  end
+end

data/test/unit/gem_logger/logger_support_test.rb

@@ -0,0 +1,192 @@
+require_relative '../../test_helper'
+
+module GemLogger
+  class LoggerSupportTest < Minitest::Should::TestCase
+    
+    setup do
+      @uniq = SecureRandom.uuid.gsub("-", "")
+    end
+    
+    teardown do
+      LoggerSupportTest.constants.grep(/^Foo/).each do |c|
+        LoggerSupportTest.send(:remove_const, c)
+      end
+    end
+    
+    def new_module(module_name, &block)
+      mod = self.class.const_set module_name, Module.new
+      mod.class_eval(&block)
+      mod
+    end
+    
+    # can't do this dynamically as the class name needs to be set at inheritance time for lumber to work
+    def new_class(class_name, super_class=nil, &block)
+      s = "class #{class_name}"
+      s << " < #{super_class}" if super_class
+      s << "; end"
+    
+      eval(s)
+      clazz = self.class.const_get(class_name)
+      clazz.class_eval(&block)
+      clazz
+    end
+    
+    context "BasicLogger" do
+      
+      setup do
+        @old_default_logger = GemLogger.default_logger
+        GemLogger.default_logger = Minitest::Mock.new
+      end
+    
+      teardown do
+        GemLogger.default_logger.verify
+        GemLogger.default_logger = @old_default_logger
+      end
+
+      should "have a logger instance accessible from an instance method" do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def member_method; logger.debug('hi'); end; }
+        assert foo.new.respond_to?(:logger)
+        foo.logger.expect(:debug, nil, ['hi'])
+        foo.new.member_method
+      end
+    
+      should "have a logger instance accessible from a class method " do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; logger.debug('hi'); end; }
+        assert foo.respond_to?(:logger)
+        foo.logger.expect(:debug, nil, ['hi'])
+        foo.class_method
+      end
+    
+      should "have a logger instance when in a nested module" do
+        foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
+        foo = new_class("Foo#{@uniq}") { include foomod; def member_method; logger.debug('hi'); end; }
+        assert foo.new.respond_to?(:logger)
+        foo.logger.expect(:debug, nil, ['hi'])
+        foo.new.member_method
+      end
+    
+      should "fail when included in a module that is not a Concern" do
+        assert_raises(ArgumentError) do
+          new_module("FooMod#{@uniq}") { include GemLogger::LoggerSupport; }
+        end
+      end
+      
+      should "have a log_exception method accessible from an instance method" do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def member_method; log_exception(RuntimeError.new("hell")); end; }
+        assert foo.new.respond_to?(:log_exception)
+        foo.logger.expect(:error, nil, [/.*/])
+        foo.new.member_method
+      end
+    
+      should "have a log_exception method accessible from a class method " do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("hell")); end; }
+        assert foo.respond_to?(:log_exception)
+        foo.logger.expect(:error, nil, [/.*/])
+        foo.class_method
+      end
+    
+      should "log_exception should populate class name as controller and method name as action" do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("hell")); end; }
+        foo.logger.expect(:error, nil, [/.*/])
+        foo.class_method
+      end
+    
+      should "not raise exception on bad encoding" do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("\xE2".force_encoding('ASCII-8BIT'))); end; }
+        foo.logger.expect(:error, nil, [/.*/])
+        foo.class_method
+      end
+    
+      context 'Generate Message' do
+        should 'properly generate messages with a message prefix' do
+          foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
+          assert_match /^prefix /, foo.generate_message(StandardError.new('Hello'), {:message_prefix => 'prefix'})
+        end
+    
+        should 'properly generate messages with a blank message prefix' do
+          foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
+          assert_match /^#<StandardError: Hello>/, foo.generate_message(StandardError.new('Hello'), {:message_prefix => ''})
+        end
+    
+        should 'properly generate messages with no message prefix' do
+          foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
+          assert_match /^#<StandardError: Hello>/, foo.generate_message(StandardError.new('Hello'), {})
+        end
+      end
+
+    end
+    
+    context "lumber integration" do
+      
+      setup do
+        require 'lumber'
+        
+        yml = <<-EOF
+          log4r_config:
+            pre_config:
+              root:
+                level: 'DEBUG'
+            loggers:
+              - name: "rails"
+                level: DEBUG
+            outputters: []
+        EOF
+        
+        cfg = Log4r::YamlConfigurator
+        cfg.load_yaml_string(yml)
+        logger = Log4r::Logger['rails']
+        sio = StringIO.new 
+        logger.outputters = [Log4r::IOOutputter.new("sbout", sio)]
+        
+        Log4r::YamlConfigurator.stub(:load_yaml_file, nil) do
+          root = File.expand_path("../../..", __FILE__)
+          Lumber.init(:root => root, :env => 'test', :config_file => __FILE__)
+        end
+        
+        @old_logger_concern = GemLogger.logger_concern
+        GemLogger.logger_concern = Lumber::LoggerSupport
+      end
+      
+      teardown do
+        GemLogger.logger_concern = @old_logger_concern
+      end
+    
+      should "have a logger instance accessible from an instance method" do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.new.logger.fullname
+      end
+    
+      should "have a logger instance accessible from a class method " do
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
+      end
+    
+      should "have a logger instance when in a nested module" do
+        foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
+        foo = new_class("Foo#{@uniq}") { include foomod; }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
+      end
+    
+      should "have correct logger instance with multiple includes" do
+        foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
+        foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; include foomod; }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
+      end
+    
+      should "have correct logger instance with includes and inheritance" do
+        foosuper = new_class("FooSuper#{@uniq}") { include GemLogger::LoggerSupport; }
+        foo = new_class("Foo#{@uniq}", foosuper) { }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foosuper.name.split('::').last}::#{foo.name.split('::').last}", foo.logger.fullname
+      end
+    
+      should "have correct logger instance with multiple includes and inheritance" do
+        foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
+        foosuper = new_class("FooSuper#{@uniq}") { include foomod; }
+        foo = new_class("Foo#{@uniq}", foosuper) { include GemLogger::LoggerSupport; include foomod; }
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foosuper.name.split('::').last}::#{foo.name.split('::').last}", foo.logger.fullname
+      end
+
+    end
+
+  end
+end

data/test/unit/gem_logger_test.rb

@@ -0,0 +1,38 @@
+require_relative '../test_helper'
+
+class GemLoggerTest < MiniTest::Should::TestCase
+  
+  context "configure" do
+    
+    should "provide a default value for default_logger" do
+      GemLogger.default_logger = nil
+      assert_instance_of Logger, GemLogger.default_logger
+    end
+    
+    should "provide a default value for logger_concern" do
+      assert_equal GemLogger::BasicLogger, GemLogger.logger_concern
+    end
+
+    should "allow config through #configure" do
+      old_logger = GemLogger.default_logger
+      old_concern = GemLogger.logger_concern
+
+      begin
+        logger = Logger.new(STDOUT)
+        concern = Module.new { FOO = 'bar' }
+        GemLogger.configure do |config|
+          config.default_logger = logger
+          config.logger_concern = concern
+        end
+        
+        assert_equal logger, GemLogger.default_logger
+        assert_equal concern, GemLogger.logger_concern
+      ensure
+        GemLogger.default_logger = old_logger
+        GemLogger.logger_concern = old_concern
+      end
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: gem_logger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Conway
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: minitest_should
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  type: :runtime
+description: Allows classes/modules in gems to have logger class/instance methods
+  with a pluggable Logger implementation
+email:
+- matt@conwaysplace.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gem_logger.gemspec
+- lib/gem_logger.rb
+- lib/gem_logger/basic_logger.rb
+- lib/gem_logger/logger_support.rb
+- lib/gem_logger/version.rb
+- test/test_helper.rb
+- test/unit/gem_logger/basic_logger_test.rb
+- test/unit/gem_logger/logger_support_test.rb
+- test/unit/gem_logger_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Allows classes/modules in gems to have logger class/instance methods with
+  a pluggable Logger implementation
+test_files:
+- test/test_helper.rb
+- test/unit/gem_logger/basic_logger_test.rb
+- test/unit/gem_logger/logger_support_test.rb
+- test/unit/gem_logger_test.rb