yell 1.4.0 → 2.2.2

data/spec/yell/logger_spec.rb

@@ -1,263 +0,0 @@
-require 'spec_helper'
-
-class LoggerFactory
-  attr_accessor :logger
-
-  def foo
-    logger.info :foo
-  end
-
-  def bar
-    logger.info :bar
-  end
-end
-
-describe Yell::Logger do
-  let(:filename) { fixture_path + '/logger.log' }
-
-  describe "a Logger instance" do
-    let(:logger) { Yell::Logger.new }
-    subject { logger }
-
-    its(:name) { should be_nil }
-
-    context "log methods" do
-      it { should respond_to(:debug) }
-      it { should respond_to(:debug?) }
-
-      it { should respond_to(:info) }
-      it { should respond_to(:info?) }
-
-      it { should respond_to(:warn) }
-      it { should respond_to(:warn?) }
-
-      it { should respond_to(:error) }
-      it { should respond_to(:error?) }
-
-      it { should respond_to(:fatal) }
-      it { should respond_to(:fatal?) }
-
-      it { should respond_to(:unknown) }
-      it { should respond_to(:unknown?) }
-    end
-
-    context "default #adapters" do
-      subject { logger.adapters }
-
-      its(:size) { should eq(1) }
-      its(:first) { should be_kind_of(Yell::Adapters::File) }
-    end
-
-    context "default #level" do
-      subject { logger.level }
-
-      it { should be_instance_of(Yell::Level) }
-      its(:severities) { should eq([true, true, true, true, true, true]) }
-    end
-
-    context "default #trace" do
-      subject { logger.trace }
-
-      it { should be_instance_of(Yell::Level) }
-      its(:severities) { should eq([false, false, false, true, true, true]) } # from error onwards
-    end
-  end
-
-  describe "initialize with #name" do
-    let(:name) { 'test' }
-    let!(:logger) { Yell.new(:name => name) }
-
-    it "should be added to the repository" do
-      expect(Yell::Repository[name]).to eq(logger)
-    end
-  end
-
-  context "initialize with #level" do
-    let(:level) { :error }
-    let(:logger) { Yell.new(:level => level) }
-    subject { logger.level }
-
-    it { should be_instance_of(Yell::Level) }
-    its(:severities) { should eq([false, false, false, true, true, true]) }
-  end
-
-  context "initialize with #trace" do
-    let(:trace) { :info }
-    let(:logger) { Yell.new(:trace => trace) }
-    subject { logger.trace }
-
-    it { should be_instance_of(Yell::Level) }
-    its(:severities) { should eq([false, true, true, true, true, true]) }
-  end
-
-  context "initialize with #silence" do
-    let(:silence) { "test" }
-    let(:logger) { Yell.new(:silence => silence) }
-    subject { logger.silencer }
-
-    it { should be_instance_of(Yell::Silencer) }
-    its(:patterns) { should eq([silence]) }
-  end
-
-  context "initialize with a #filename" do
-    it "should call adapter with :file" do
-      mock.proxy(Yell::Adapters::File).new(:filename => filename)
-
-      Yell::Logger.new(filename)
-    end
-  end
-
-  context "initialize with a #filename of Pathname type" do
-    let(:pathname) { Pathname.new(filename) }
-
-    it "should call adapter with :file" do
-      mock.proxy(Yell::Adapters::File).new(:filename => pathname)
-
-      Yell::Logger.new(pathname)
-    end
-  end
-
-  context "initialize with a :stdout adapter" do
-    before { mock.proxy(Yell::Adapters::Stdout).new(anything) }
-
-    it "should call adapter with STDOUT" do
-      Yell::Logger.new(STDOUT)
-    end
-
-    it "should call adapter with :stdout" do
-      Yell::Logger.new(:stdout)
-    end
-  end
-
-  context "initialize with a :stderr adapter" do
-    before { mock.proxy(Yell::Adapters::Stderr).new(anything) }
-
-    it "should call adapter with STDERR" do
-      Yell::Logger.new(STDERR)
-    end
-
-    it "should call adapter with :stderr" do
-      Yell::Logger.new(:stderr)
-    end
-  end
-
-  context "initialize with a block" do
-    let(:level) { Yell::Level.new :error }
-    let(:stdout) { Yell::Adapters::Stdout.new }
-    let(:adapters) { loggr.instance_variable_get(:@adapters) }
-
-    context "with arity" do
-      subject do
-        Yell::Logger.new(:level => level) { |l| l.adapter(:stdout) }
-      end
-
-      its(:level) { should eq(level) }
-      its('adapters.size') { should eq(1) }
-      its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
-    end
-
-    context "without arity" do
-      subject do
-        Yell::Logger.new(:level => level) { adapter(:stdout) }
-      end
-
-      its(:level) { should eq(level) }
-      its('adapters.size') { should eq(1) }
-      its('adapters.first') { should be_instance_of(Yell::Adapters::Stdout) }
-    end
-  end
-
-  context "initialize with #adapters option" do
-    let(:logger) do
-      Yell::Logger.new(:adapters => [:stdout, {:stderr => {:level => :error}}])
-    end
-
-    let(:adapters) { logger.instance_variable_get(:@adapters) }
-    let(:stdout) { adapters.first }
-    let(:stderr) { adapters.last }
-
-    it "should define those adapters" do
-      expect(adapters.size).to eq(2)
-
-      expect(stdout).to be_kind_of(Yell::Adapters::Stdout)
-      expect(stderr).to be_kind_of(Yell::Adapters::Stderr)
-    end
-
-    it "should pass :level to :stderr adapter" do
-      expect(stderr.level.at?(:warn)).to be_false
-      expect(stderr.level.at?(:error)).to be_true
-      expect(stderr.level.at?(:fatal)).to be_true
-    end
-  end
-
-  context "caller's :file, :line and :method" do
-    let(:stdout) { Yell::Adapters::Stdout.new(:format => "%F, %n: %M") }
-    let(:logger) { Yell::Logger.new(:trace => true) { |l| l.adapter(stdout) } }
-
-    it "should write correctly" do
-      factory = LoggerFactory.new
-      factory.logger = logger
-
-      mock(stdout.send(:stream)).syswrite("#{__FILE__}, 7: foo\n")
-      mock(stdout.send(:stream)).syswrite("#{__FILE__}, 11: bar\n")
-
-      factory.foo
-      factory.bar
-    end
-  end
-
-  context "logging in general" do
-    let(:logger) { Yell::Logger.new(filename, :format => "%m") }
-    let(:line) { File.open(filename, &:readline) }
-
-    it "should output a single message" do
-      logger.info "Hello World"
-
-      expect(line).to eq("Hello World\n")
-    end
-
-    it "should output multiple messages" do
-      logger.info "Hello", "W", "o", "r", "l", "d"
-
-      expect(line).to eq("Hello W o r l d\n")
-    end
-
-    it "should output a hash and message" do
-      logger.info "Hello World", :test => :message
-
-      expect(line).to eq("Hello World test: message\n")
-    end
-
-    it "should output a hash and message" do
-      logger.info( {:test => :message}, "Hello World" )
-
-      expect(line).to eq("test: message Hello World\n")
-    end
-
-    it "should output a hash and block" do
-      logger.info(:test => :message) { "Hello World" }
-
-      expect(line).to eq("test: message Hello World\n")
-    end
-  end
-
-  context "logging with a silencer" do
-    let(:silence) { "this" }
-    let(:stdout) { Yell::Adapters::Stdout.new }
-    let(:logger) { Yell::Logger.new(stdout, :silence => silence) }
-
-    it "should not pass a matching message to any adapter" do
-      dont_allow(stdout).write
-
-      logger.info "this should not be logged"
-    end
-
-    it "should pass a non-matching message to any adapter" do
-      mock(stdout).write(is_a(Yell::Event))
-
-      logger.info "that should be logged"
-    end
-  end
-
-end
-

data/spec/yell/repository_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Repository do
-  let(:name) { 'test' }
-  let(:logger) { Yell.new(:stdout) }
-
-  subject { Yell::Repository[name] }
-
-  context ".[]" do
-    it "should raise when not set" do
-      expect { subject }.to raise_error(Yell::LoggerNotFound)
-    end
-
-    context "when logger with :name exists" do
-      let!(:logger) { Yell.new(:stdout, :name => name) }
-
-      it { should eq(logger) }
-    end
-
-    context "given a Class" do
-      let!(:logger) { Yell.new(:stdout, :name => "Numeric") }
-
-      it "should raise with the correct :name when logger not found" do
-        mock.proxy(Yell::LoggerNotFound).new(String)
-        lambda { Yell::Repository[String] }.should raise_error(Yell::LoggerNotFound)
-      end
-
-      it "should return the logger" do
-        Yell::Repository[Numeric].should eq(logger)
-      end
-
-      it "should return the logger when superclass has it defined" do
-        Yell::Repository[Integer].should eq(logger)
-      end
-    end
-  end
-
-  context ".[]=" do
-    before { Yell::Repository[name] = logger }
-    it { should eq(logger) }
-  end
-
-  context ".[]= with a named logger" do
-    let!(:logger) { Yell.new(:stdout, :name => name) }
-    before { Yell::Repository[name] = logger }
-
-    it { should eq(logger) }
-  end
-
-  context ".[]= with a named logger of a different name" do
-    let(:other) { 'other' }
-    let(:logger) { Yell.new(:stdout, :name => other) }
-    before { Yell::Repository[name] = logger }
-
-    it "should add logger to both repositories" do
-      Yell::Repository[name].should eq(logger)
-      Yell::Repository[other].should eq(logger)
-    end
-  end
-
-  context "loggers" do
-    let(:loggers) { { name => logger } }
-    subject { Yell::Repository.loggers }
-    before { Yell::Repository[name] = logger }
-
-    it { should eq(loggers) }
-  end
-
-end
-

data/spec/yell/silencer_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Silencer do
-
-  context "initialize with #patterns" do
-    subject { Yell::Silencer.new(/this/) }
-
-    its(:patterns) { should eq([/this/]) }
-  end
-
-  context "#add" do
-    let(:silencer) { Yell::Silencer.new }
-
-    it "should add patterns" do
-      silencer.add /this/, /that/
-
-      expect(silencer.patterns).to eq([/this/, /that/])
-    end
-
-    it "should ignore duplicate patterns" do
-      silencer.add /this/, /that/, /this/
-
-      expect(silencer.patterns).to eq([/this/, /that/])
-    end
-  end
-
-  context "#silence?" do
-    let(:silencer) { Yell::Silencer.new }
-
-    it "should be false when no patterns present" do
-      expect(silencer.silence?).to be_false
-    end
-
-    it "should be true when patterns present" do
-      silencer.add /this/
-
-      expect(silencer.silence?).to be_true
-    end
-  end
-
-  context "#silence" do
-    let(:silencer) { Yell::Silencer.new(/this/) }
-
-    it "should reject messages that match any pattern" do
-      expect(silencer.silence("this", "that")).to eq(["that"])
-    end
-  end
-
-end

data/spec/yell_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe Yell do
-  let( :logger ) { Yell.new }
-
-  subject { logger }
-
-  it { should be_kind_of Yell::Logger }
-
-  it "should raise AdapterNotFound when adapter cant be loaded" do
-    expect {
-      Yell.new :unknownadapter
-    }.to raise_error(Yell::AdapterNotFound)
-  end
-
-  context ".level" do
-    subject { Yell.level }
-    it { should be_kind_of Yell::Level }
-  end
-
-  context ".format" do
-    subject { Yell.format( "%m" ) }
-    it { should be_kind_of Yell::Formatter }
-  end
-
-  context ".load!" do
-    subject { Yell.load!( 'yell.yml' ) }
-
-    before do
-      mock(Yell::Configuration).load!('yell.yml') { {} }
-    end
-
-    it { should be_kind_of Yell::Logger }
-  end
-
-  context ".[]" do
-    let(:name) { 'test' }
-
-    it "should delegate to the repository" do
-      mock(Yell::Repository)[name]
-
-      Yell[name]
-    end
-  end
-
-  context ".[]=" do
-    let(:name) { 'test' }
-
-    it "should delegate to the repository" do
-      mock.proxy(Yell::Repository)[name] = logger
-
-      Yell[name] = logger
-    end
-  end
-
-  context ".env" do
-    subject { Yell.env }
-
-    it "should default to YELL_ENV" do
-      subject.should == 'test'
-    end
-
-    context "fallback to RACK_ENV" do
-      before do
-        stub(ENV).key?('YELL_ENV') { false }
-        mock(ENV).key?('RACK_ENV') { true }
-
-        ENV['RACK_ENV'] = 'rack'
-      end
-
-      after { ENV.delete 'RACK_ENV' }
-
-      it { should == 'rack' }
-    end
-
-    context "fallback to RAILS_ENV" do
-      before do
-        stub(ENV).key?('YELL_ENV') { false }
-        stub(ENV).key?('RACK_ENV') { false }
-        mock(ENV).key?('RAILS_ENV') { true }
-
-        ENV['RAILS_ENV'] = 'rails'
-      end
-
-      after { ENV.delete 'RAILS_ENV' }
-
-      it { should == 'rails' }
-    end
-
-    context "fallback to development" do
-      before do
-        stub(ENV).key?('YELL_ENV') { false }
-        stub(ENV).key?('RACK_ENV') { false }
-        stub(ENV).key?('RAILS_ENV') { false }
-      end
-
-      it { should == 'development' }
-    end
-  end
-
-end
-