multiple_devices_logger 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1ab6f46b22a880122cfcf4c6b84ce37c4fb229b
+  data.tar.gz: c69bcdc6a13537e8267e98435d80d4fc48f3be97
+SHA512:
+  metadata.gz: 9938b033da846d237f8ab0746e84092e1024198026a3afd020661403eafc49a5e6ab0449a588078577f9658fcaa0784492296c0eb15d10fe17ef29e647321b72
+  data.tar.gz: c100f7447b874b85245ff97b3fed4d4c770c5977bfd1f242455d32123904e60052595dd147ffe0c9742e5f918ccf6db17f15892770f66cb09c007ce8002e7193

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+/.bundle/
+/.byebug_history
+/.ruby-version
+/Gemfile.lock
+/pkg/

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--order random

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Alexis Toulotte
+
+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.mdown

@@ -0,0 +1,74 @@
+# MultipleDevicesLogger
+
+Logger that support many and different devices for specified levels.
+
+## Setup
+
+Just add this into your `Gemfile`:
+
+```ruby
+gem 'multiple_devices_logger'
+```
+
+Then, just run a `bundle install`.
+
+## Usage
+
+### Simple usage
+
+This will add `STDOUT` device for `debug` and `info` severities and a file
+for all others.
+
+```ruby
+require 'multiple_devices_logger'
+
+logger = MultipleDevicesLogger.new
+logger.add_device(STDOUT, Logger::DEBUG, Logger::INFO)
+logger.add_device('/tmp/logs', Logger::WARN, Logger::ERROR, Logger::FATAL)
+logger.warn('BAM!')
+```
+
+Note that severty can specified as string or symbol.
+
+### Define default device
+
+If there is no device for given severity, default device is used. It can be
+defined thanks to `default_device` accessor.
+
+```ruby
+logger.default_device = STDERR
+```
+
+### Adding a device for all severities
+
+If you don't specify any severity to `#add_device` method, specified device
+will be added to all sevrities.
+
+Here is an example that logs all messages to `STDERR` and fatal messages to
+both a file and `STDERR`.
+
+```ruby
+logger.add_device(STDERR)
+logger.add_device('/tmp/fatal.log', :fatal)
+```
+
+### Operators
+
+To simplify devices definition, you can use `>`, `>=`, `<`, `<=` operators:
+
+```ruby
+logger.add_device('/var/log/myapp.log', '>= warn')
+```
+
+### Clear all devices
+
+Just use `#clear_devices` to clear all registered devices:
+
+```ruby
+logger.clear_devices
+```
+
+## Executing test suite
+
+This project is fully tested with [Rspec 3](http://github.com/rspec/rspec).
+Just run `bundle exec rake` (after a `bundle install`).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: runs specs.'
+task default: :spec
+
+desc 'Run all specs in spec directory.'
+RSpec::Core::RakeTask.new(:spec)

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/multiple_devices_logger.rb

@@ -0,0 +1,93 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/object'
+require 'logger'
+
+class MultipleDevicesLogger < Logger
+
+  SEVERITIES = {
+    'debug' => DEBUG,
+    'info' => INFO,
+    'warn' => WARN,
+    'error' => ERROR,
+    'fatal' => FATAL,
+    'unknown' => UNKNOWN,
+  }.freeze
+
+  attr_reader :default_device
+
+  def initialize
+    super(nil)
+    clear_devices
+  end
+
+  def add(severity, message = nil, progname = nil)
+    severity ||= UNKNOWN
+    return true if severity < level
+    progname ||= self.progname
+    if message.nil?
+      if block_given?
+        message = yield
+      else
+        message = progname
+        progname = self.progname
+      end
+    end
+    text = format_message(format_severity(severity), Time.now, progname, message)
+    devices_for(severity).each do |device|
+      device.write(text)
+    end
+    true
+  end
+  alias_method :log, :add
+
+  def add_device(device, *severities)
+    severities = [severities].flatten
+    options = severities.extract_options!
+    device = LogDevice.new(device, options) unless device.is_a?(LogDevice)
+    if severities.empty?
+      keys = SEVERITIES.values
+    else
+      keys = severities.map { |severity| parse_severities_with_operator(severity) }.flatten.uniq
+    end
+    keys.each do |key|
+      @devices[key] ||= []
+      @devices[key] << device
+    end
+    self
+  end
+
+  def clear_devices
+    @devices = {}
+  end
+
+  def default_device=(value)
+    @default_device = value.is_a?(LogDevice) ? value : LogDevice.new(value)
+  end
+
+  def devices_for(severity)
+    @devices[parse_severity(severity)] || [default_device].compact || []
+  end
+
+  def reopen(log = nil)
+    raise NotImplementedError.new("#{self.class}#reopen")
+  end
+
+  private
+
+  def parse_severity(value)
+    int_value = value.is_a?(Fixnum) ? value : (Integer(value.to_s) rescue nil)
+    return int_value if SEVERITIES.values.include?(int_value)
+    severity = value.to_s
+    SEVERITIES[value.to_s.strip.downcase] || raise(ArgumentError.new("Invalid log severity: #{value.inspect}"))
+  end
+
+  def parse_severities_with_operator(value)
+    if match = value.to_s.strip.match(/^([<>]=?)\s*(.+)$/)
+      operator = match[1]
+      severity = parse_severity(match[2])
+      return SEVERITIES.values.select { |l| l.send(operator, severity) }
+    end
+    [parse_severity(value)]
+  end
+
+end

data/multiple_devices_logger.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name = 'multiple_devices_logger'
+  s.version = File.read("#{File.dirname(__FILE__)}/VERSION").strip
+  s.platform = Gem::Platform::RUBY
+  s.author = 'Alexis Toulotte'
+  s.email = 'al@alweb.org'
+  s.homepage = 'https://github.com/alexistoulotte/multiple_devices_logger'
+  s.summary = 'Logger than can have many devices'
+  s.description = 'Logger that support many and different devices for specified levels'
+  s.license = 'MIT'
+
+  s.rubyforge_project = 'multiple_devices_logger'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'activesupport', '>= 5.0.0', '< 6.0.0'
+
+  s.add_development_dependency 'byebug', '>= 9.0.0', '< 10.0.0'
+  s.add_development_dependency 'rake', '>= 12.0.0', '< 13.0.0'
+  s.add_development_dependency 'rspec', '>= 3.5.0', '< 3.6.0'
+end

data/spec/multiple_devices_logger_spec.rb

@@ -0,0 +1,448 @@
+require 'spec_helper'
+
+describe MultipleDevicesLogger do
+
+  let(:logger) { MultipleDevicesLogger.new }
+
+  it 'is a Logger' do
+    expect(logger).to be_a(Logger)
+  end
+
+  describe '#add' do
+
+    before :each do
+      logger.add_device(STDERR, '>= WARN')
+    end
+
+    it 'write to device' do
+      expect(STDERR).to receive(:write).with(/BAM!/)
+      logger.add(Logger::WARN, 'BAM!')
+    end
+
+    it 'use a default formatter' do
+      expect(STDERR).to receive(:write).with(/^W, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+ #\d+\]  WARN -- MyApp: BAM!\n$/)
+      logger.add(Logger::WARN, 'BAM!', 'MyApp')
+    end
+
+    it 'write to multiple device if configured' do
+      logger.add_device(STDOUT)
+      expect(STDERR).to receive(:write).with(/BAM!/)
+      expect(STDOUT).to receive(:write).with(/BAM!/)
+      logger.add(Logger::WARN, 'BAM!')
+    end
+
+    it 'does not write anything if given severity is lower than configured level' do
+      logger.level = :error
+      expect(STDERR).not_to receive(:write)
+      logger.add(Logger::WARN, 'BAM!')
+    end
+
+    it 'severity is UNKNOWN if not specified' do
+      expect(STDERR).to receive(:write).with(/ANY -- : BIM!/)
+      logger.add(nil, 'BIM!')
+    end
+
+    it 'a block can be given' do
+      expect(STDERR).to receive(:write).with(/BIM!/)
+      logger.add(Logger::ERROR) { 'BIM!' }
+    end
+
+    it 'accepts progname' do
+      expect(STDERR).to receive(:write).with(/FATAL -- MyApp: BAM!/)
+      logger.add(Logger::FATAL, 'BAM!', 'MyApp')
+    end
+
+    it 'returns true' do
+      expect(STDERR).to receive(:write)
+      expect(logger.add(Logger::WARN, 'BAM!')).to be(true)
+    end
+
+    it 'returns true if nothing is written' do
+      logger.level = :error
+      expect(STDERR).not_to receive(:write)
+      expect(logger.add(Logger::WARN, 'BAM!')).to be(true)
+    end
+
+    it 'block is ignored if message is given' do
+      expect(STDERR).to receive(:write).with(/BAM!/)
+      logger.add(Logger::WARN, 'BAM!') { 'BIM!' }
+    end
+
+    it 'message is progname if nil' do
+      expect(STDERR).to receive(:write).with(/WARN -- : BAM!/)
+      logger.add(Logger::WARN, nil, 'BAM!')
+    end
+
+    it 'a formatter could be given' do
+      logger.formatter = -> (severity, time, progname, message) { "Hello #{progname}: #{message}"  }
+      expect(STDERR).to receive(:write).with('Hello World: cool')
+      logger.add(Logger::WARN, 'cool', 'World')
+    end
+
+  end
+
+  describe '#add_device' do
+
+    it 'adds a device for all severities if given severity is nil' do
+      expect {
+        logger.add_device(STDOUT)
+      }.to change { logger.devices_for(Logger::INFO).size }.by(1)
+      expect(logger.devices_for(Logger::WARN).first.dev).to be(STDOUT)
+    end
+
+    it 'does not adds to other severities if severity is specified' do
+      logger.add_device(STDERR, Logger::WARN)
+      expect(logger.devices_for(Logger::WARN)).not_to be_empty
+      expect(logger.devices_for(Logger::INFO)).to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'severity can be specified as constant' do
+      expect {
+        logger.add_device(STDERR, Logger::WARN)
+      }.to change { logger.devices_for(Logger::WARN).first.try(:dev) }.from(nil).to(STDERR)
+    end
+
+    it 'severity can be specified as symbol' do
+      expect {
+        logger.add_device(STDOUT, :warn)
+      }.to change { logger.devices_for(Logger::WARN).size }.by(1)
+    end
+
+    it 'severity can be specified as symbol (ignore case)' do
+      expect {
+        logger.add_device(STDOUT, :waRN)
+      }.to change { logger.devices_for(Logger::WARN).size }.by(1)
+    end
+
+    it 'severity can be specified as string' do
+      expect {
+        logger.add_device(STDOUT, 'fatal')
+      }.to change { logger.devices_for(Logger::FATAL).size }.by(1)
+    end
+
+    it 'severity can be specified as string (ignore case)' do
+      expect {
+        logger.add_device(STDOUT, 'FATal')
+      }.to change { logger.devices_for(Logger::FATAL).size }.by(1)
+    end
+
+    it 'severity can be specified as string (with extra spaces)' do
+      expect {
+        logger.add_device(STDOUT, " fatal \n")
+      }.to change { logger.devices_for(Logger::FATAL).size }.by(1)
+    end
+
+    it 'severity can be specified as integer' do
+      expect {
+        logger.add_device(STDOUT, 0)
+      }.to change { logger.devices_for(Logger::DEBUG).size }.by(1)
+    end
+
+    it 'severity can be specified as integer (as string)' do
+      expect {
+        logger.add_device(STDOUT, '3')
+      }.to change { logger.devices_for(Logger::ERROR).size }.by(1)
+    end
+
+    it 'severity can be specified as integer (as string with spaces)' do
+      expect {
+        logger.add_device(STDOUT, ' 2  ')
+      }.to change { logger.devices_for(Logger::WARN).size }.by(1)
+    end
+
+    it 'many severities can be given' do
+      logger.add_device(STDERR, Logger::DEBUG, Logger::WARN)
+      expect(logger.devices_for(Logger::DEBUG)).not_to be_empty
+      expect(logger.devices_for(Logger::WARN)).not_to be_empty
+      expect(logger.devices_for(Logger::INFO)).to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'an array of severities can be given' do
+      logger.add_device(STDERR, [Logger::DEBUG, Logger::WARN])
+      expect(logger.devices_for(Logger::DEBUG)).not_to be_empty
+      expect(logger.devices_for(Logger::WARN)).not_to be_empty
+      expect(logger.devices_for(Logger::INFO)).to be_empty
+    end
+
+    it 'avoids doubloons on severities' do
+      logger.add_device(STDOUT, Logger::DEBUG, Logger::INFO, Logger::DEBUG)
+      expect(logger.devices_for(Logger::DEBUG).size).to eq(1)
+    end
+
+    it 'raise an error if severity specified as integer is too high' do
+      expect {
+        logger.add_device(STDERR, 8)
+      }.to raise_error(ArgumentError, 'Invalid log severity: 8')
+    end
+
+    it 'raise an error if severity specified as integer is negative' do
+      expect {
+        logger.add_device(STDERR, -1)
+      }.to raise_error(ArgumentError, 'Invalid log severity: -1')
+    end
+
+    it 'does not add any device if one severity is invalid' do
+      expect {
+        expect {
+          logger.add_device(STDOUT, Logger::DEBUG, 'bim')
+        }.to raise_error(ArgumentError, 'Invalid log severity: "bim"')
+      }.not_to change { logger.devices_for(Logger::DEBUG).size }
+    end
+
+    it 'raise an error if severity is unknown (as string)' do
+      expect {
+        logger.add_device(STDOUT, 'errors')
+      }.to raise_error(ArgumentError, 'Invalid log severity: "errors"')
+    end
+
+    it 'may have many device for a severity' do
+      logger.add_device(STDERR, Logger::INFO).add_device(STDOUT, Logger::INFO)
+      expect(logger.devices_for(Logger::DEBUG)).to be_empty
+      expect(logger.devices_for(Logger::INFO).size).to eq(2)
+      expect(logger.devices_for(Logger::FATAL)).to be_empty
+    end
+
+    it 'returns self' do
+      expect(logger.add_device(STDOUT)).to be(logger)
+      expect(logger.add_device(STDOUT, Logger::DEBUG)).to be(logger)
+    end
+
+    it 'accepts <= operator' do
+      logger.add_device(STDOUT, '<= warn')
+      expect(logger.devices_for(Logger::DEBUG)).not_to be_empty
+      expect(logger.devices_for(Logger::INFO)).not_to be_empty
+      expect(logger.devices_for(Logger::WARN)).not_to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'accepts < operator' do
+      logger.add_device(STDOUT, '< warn')
+      expect(logger.devices_for(Logger::DEBUG)).not_to be_empty
+      expect(logger.devices_for(Logger::INFO)).not_to be_empty
+      expect(logger.devices_for(Logger::WARN)).to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'accepts > operator' do
+      logger.add_device(STDOUT, '> error')
+      expect(logger.devices_for(Logger::UNKNOWN)).not_to be_empty
+      expect(logger.devices_for(Logger::FATAL)).not_to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'accepts >= operator' do
+      logger.add_device(STDOUT, '>= error')
+      expect(logger.devices_for(Logger::UNKNOWN)).not_to be_empty
+      expect(logger.devices_for(Logger::FATAL)).not_to be_empty
+      expect(logger.devices_for(Logger::ERROR)).not_to be_empty
+      expect(logger.devices_for(Logger::WARN)).to be_empty
+    end
+
+    it 'accepts operator with spaces and with a different case' do
+      logger.add_device(STDOUT, " \n > eRRor  ")
+      expect(logger.devices_for(Logger::UNKNOWN)).not_to be_empty
+      expect(logger.devices_for(Logger::FATAL)).not_to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'accepts operator with no spaces' do
+      logger.add_device(STDOUT, ">error")
+      expect(logger.devices_for(Logger::UNKNOWN)).not_to be_empty
+      expect(logger.devices_for(Logger::FATAL)).not_to be_empty
+      expect(logger.devices_for(Logger::ERROR)).to be_empty
+    end
+
+    it 'raise an error if operator is invalid' do
+      expect {
+        logger.add_device(STDERR, '!> error')
+      }.to raise_error(ArgumentError, 'Invalid log severity: "!> error"')
+    end
+
+    it 'raise an error if severity is invalid (with operator)' do
+      expect {
+        logger.add_device(STDERR, '>= foo')
+      }.to raise_error(ArgumentError, 'Invalid log severity: "foo"')
+    end
+
+    it 'avoid doubloons with operator' do
+      logger.add_device(STDERR, Logger::INFO, '>= DEBUG')
+      expect(logger.devices_for(Logger::DEBUG).size).to eq(1)
+      expect(logger.devices_for(Logger::INFO).size).to eq(1)
+      expect(logger.devices_for(Logger::WARN).size).to eq(1)
+    end
+
+    it 'may have many devices for a severity with an operator' do
+      logger.add_device(STDERR, Logger::INFO).add_device(STDOUT, '<= error')
+      expect(logger.devices_for(Logger::DEBUG).size).to eq(1)
+      expect(logger.devices_for(Logger::INFO).size).to eq(2)
+      expect(logger.devices_for(Logger::FATAL)).to be_empty
+    end
+
+    it 'register LogDevice directly if a LogDevice is given' do
+      device = Logger::LogDevice.new(STDERR)
+      logger.add_device(device, Logger::INFO)
+      expect(logger.devices_for(Logger::INFO).first).to be(device)
+    end
+
+    it 'given options are forwared to LogDevice constructor' do
+      expect(Logger::LogDevice).to receive(:new).with(STDOUT, foo: 'bar')
+      logger.add_device(STDOUT, Logger::INFO, foo: 'bar')
+    end
+
+    it 'raise an error for default severity' do
+      expect {
+        logger.add_device(STDERR, 'default')
+      }.to raise_error(ArgumentError, 'Invalid log severity: "default"')
+    end
+
+  end
+
+  describe '#clear_devices' do
+
+    it 'removes registered loggers' do
+      logger.add_device(STDERR)
+      expect {
+        logger.clear_devices
+      }.to change { logger.devices_for(Logger::DEBUG) }.to([])
+    end
+
+  end
+
+  describe '#default_device' do
+
+    it 'is nil by default' do
+      expect(logger.default_device).to be_nil
+    end
+
+    it 'can be changed' do
+      logger.default_device = STDERR
+      expect(logger.default_device).not_to be_nil
+    end
+
+    it 'is converted to a LogDevice when set' do
+      logger.default_device = STDERR
+      expect(logger.default_device).to be_a(Logger::LogDevice)
+      expect(logger.default_device.dev).to be(STDERR)
+    end
+
+    it 'is not converted to a LogDevice when a LogDevice is set' do
+      device = Logger::LogDevice.new(STDOUT)
+      logger.default_device = device
+      expect(logger.default_device).to be(device)
+      expect(logger.default_device.dev).to be(STDOUT)
+    end
+
+  end
+
+  describe '#devices_for' do
+
+    it 'accepts strings' do
+      logger.add_device(STDERR, 'warn')
+      expect(logger.devices_for('warn').size).to eq(1)
+    end
+
+    it 'returns a LogDevice instance' do
+      logger.add_device(STDERR, 'warn')
+      expect(logger.devices_for(:warn).first).to be_a(Logger::LogDevice)
+      expect(logger.devices_for(:warn).first.dev).to be(STDERR)
+    end
+
+    it 'returns an empty array if there is not registered device for given severity' do
+      expect(logger.devices_for(Logger::WARN)).to eq([])
+    end
+
+    it 'returns default device if there is no device for given severity' do
+      logger.default_device = STDERR
+      logger.add_device(STDOUT, '>= warn')
+      expect(logger.devices_for(:debug).first.dev).to be(STDERR)
+      expect(logger.devices_for(:warn).first.dev).to be(STDOUT)
+      expect(logger.devices_for(:error).first.dev).to be(STDOUT)
+    end
+
+    it 'default is never used if a logger has been added to all severity' do
+      logger.default_device = STDERR
+      logger.add_device(STDOUT)
+      expect(logger.devices_for(:debug).first.dev).to be(STDOUT)
+      expect(logger.devices_for(:warn).first.dev).to be(STDOUT)
+      expect(logger.devices_for(:error).first.dev).to be(STDOUT)
+    end
+
+  end
+
+  describe '#initialize' do
+
+    it 'accepts no argument' do
+      expect {
+        MultipleDevicesLogger.new
+      }.not_to raise_error
+    end
+
+    it 'logdev is nil' do
+      expect(logger.instance_variable_get(:@logdev)).to be_nil
+    end
+
+  end
+
+  describe '#level' do
+
+    it 'is debug by default' do
+      expect(logger.level).to eq(Logger::DEBUG)
+    end
+
+    it 'is not changed when adding devices' do
+      expect {
+        logger.add_device(STDOUT, '> WARN')
+      }.not_to change { logger.level }
+    end
+
+  end
+
+  describe '#log' do
+
+    it 'works like expected' do
+      logger.add_device(STDOUT, Logger::WARN)
+      expect(STDOUT).to receive(:write).with(/WARN -- : BAM!/)
+      logger.log(Logger::WARN, 'BAM!')
+    end
+
+  end
+
+  describe '#reopen' do
+
+    it 'raise an NotImplementedError' do
+      expect {
+        logger.reopen
+      }.to raise_error(NotImplementedError, 'MultipleDevicesLogger#reopen')
+    end
+
+  end
+
+  describe '#warn' do
+
+    it 'does not output anything if there is no device' do
+      logger.add_device(STDOUT, Logger::DEBUG)
+      expect(STDOUT).not_to receive(:write)
+      logger.warn('BAM!')
+    end
+
+    it 'output message to device if configured' do
+      logger.add_device(STDOUT, Logger::WARN)
+      expect(STDOUT).to receive(:write).with(/WARN -- : BAM!/)
+      logger.warn('BAM!')
+    end
+
+  end
+
+  describe '@logdev' do
+
+    let(:logdev) { logger.instance_variable_get(:@logdev) }
+
+    it 'is nil' do
+      expect(logdev).to be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require File.expand_path("#{__dir__}/../lib/multiple_devices_logger")
+require 'byebug'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: multiple_devices_logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexis Toulotte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+description: Logger that support many and different devices for specified levels
+email: al@alweb.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- MIT-LICENSE
+- README.mdown
+- Rakefile
+- VERSION
+- lib/multiple_devices_logger.rb
+- multiple_devices_logger.gemspec
+- spec/multiple_devices_logger_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alexistoulotte/multiple_devices_logger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: multiple_devices_logger
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Logger than can have many devices
+test_files:
+- spec/multiple_devices_logger_spec.rb
+- spec/spec_helper.rb