multiple_devices_logger 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1000616e326879c8aa96b1820511a75e68f472a8
-  data.tar.gz: 47d4cd971b820a285f068d3526280ba1d7f7ab40
+  metadata.gz: 8c8875aa3e930caeabc8f1da4e1b29e0c0048fcc
+  data.tar.gz: 94dc37b500f66c4ee3cf466085baf6b8a4062cf2
 SHA512:
-  metadata.gz: 16164c8ee3bc608b3db7d995e4033a491275c76b439a964c408fc4c5be649a5c6e7c163c617612bfb3c12f2912ad169461817f6f7c840899402fcf7210fd5ebd
-  data.tar.gz: d92a152b1caaef9d7ec768a47120ea494018f4209d262f8bbdc0c58badffea0dbd6fa2af285006a51740726d19814c93dfabda4ae89f0000641aadabed864714
+  metadata.gz: 06dd0de6cfffb45e360626b98b974e4aff73980b72e64efe9048dc7b0e195c6d82d4abcc2e79b822e39e1efcd0d021496a1011dc8540eb45343a0f001d160044
+  data.tar.gz: 9c5d2050463dad9d124114c479b4b39a4c4444628bc337c3018272558c772983ea3de512c283d19f5cd17122720d4ca861d3c747ee0509557f0c73572c1ab19f

data/VERSION

@@ -1 +1 @@
-2.0.2
+2.0.3

data/multiple_devices_logger.gemspec

@@ -9,8 +9,7 @@ Gem::Specification.new do |s|
   s.description = 'Logger that support many and different devices for specified levels'
   s.license = 'MIT'
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files = `git ls-files | grep -vE '^(spec/|test/|\\.|Gemfile|Rakefile)'`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiple_devices_logger
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -76,17 +76,11 @@ 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
@@ -107,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Logger than can have many devices

data/.gitignore

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

data/.rspec

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

data/Gemfile

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

data/Rakefile

@@ -1,10 +0,0 @@
-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/spec/multiple_devices_logger_spec.rb

@@ -1,508 +0,0 @@
-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 'use formatter set' do
-      logger.add_device(STDERR, '> debug', formatter: -> (severity, time, progname, message) { "Hello #{message}" })
-      expect(STDERR).to receive(:write).with('Hello John')
-      logger.add(Logger::INFO, 'John')
-    end
-
-    it 'use default formatter if not set' 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
-
-    it 'use default formatter if formatter set via #set_formatter does not match severity' do
-      logger.add_device(STDERR, '<= info', formatter: -> (severity, time, progname, message) { "Hello #{message}" })
-
-      expect(STDERR).to receive(:write).with(/WARN -- : John/)
-      logger.add(Logger::WARN, 'John')
-
-      expect(STDERR).to receive(:write).with('Hello John')
-      logger.add(Logger::DEBUG, 'John')
-
-      expect(STDERR).to receive(:write).with('Hello John')
-      logger.add(Logger::INFO, 'John')
-    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).size }.by(1)
-    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
-      device = Logger::LogDevice.new(STDOUT)
-      expect(Logger::LogDevice).to receive(:new).with(STDOUT, foo: 'bar').and_return(device)
-      logger.add_device(STDOUT, Logger::INFO, foo: 'bar')
-    end
-
-    it 'does not forward :formatter option to log device constructor' do
-      device = Logger::LogDevice.new(STDOUT)
-      expect(Logger::LogDevice).to receive(:new).with(STDOUT, foo: 'bar').and_return(device)
-      logger.add_device(STDOUT, Logger::INFO, foo: 'bar', formatter: -> {})
-    end
-
-    it 'raise an error for default severity' do
-      expect {
-        logger.add_device(STDERR, 'default')
-      }.to raise_error(ArgumentError, 'Invalid log severity: "default"')
-    end
-
-    it 'raise an error if formatter is not a proc' do
-      expect {
-        logger.add_device(STDOUT, formatter: :foo)
-      }.to raise_error(ArgumentError, 'Formatter must respond to #call, :foo given')
-    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 '#level=' do
-
-    it 'changes level' do
-      expect {
-        logger.level = Logger::INFO
-      }.to change { logger.level }.to(Logger::INFO)
-    end
-
-    it 'accepts symbols' do
-      expect {
-        logger.level = :warn
-      }.to change { logger.level }.to(Logger::WARN)
-    end
-
-    it 'accepts string' do
-      expect {
-        logger.level = 'Error'
-      }.to change { logger.level }.to(Logger::ERROR)
-    end
-
-    it 'raise an error if invalid' do
-      expect {
-        logger.level = :foo
-      }.to raise_error(ArgumentError, 'Invalid log severity: :foo')
-    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

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