yell 2.2.0 → 2.2.1

data/spec/yell/loggable_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-class LoggableFactory
-  include Yell::Loggable
-end
-
-describe Yell::Loggable do
-  let(:factory) { LoggableFactory.new }
-
-  it "responds with logger" do
-    expect(factory).to respond_to(:logger)
-  end
-
-  it "should make a lookup in the Yell::Repository" do
-    expect(Yell::Repository).to(
-      receive(:[]).with(LoggableFactory)
-    )
-
-    factory.logger
-  end
-end

data/spec/yell/logger_spec.rb

@@ -1,290 +0,0 @@
-require 'spec_helper'
-
-class LoggerFactory
-  attr_accessor :logger
-
-  def info
-    logger.info :foo
-  end
-
-  def add
-    logger.add 1, :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 }
-
-    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 #name" do
-      its(:name) { should eq("<Yell::Logger##{logger.object_id}>") }
-
-      it "should not be added to the repository" do
-        expect { Yell::Repository[logger.name] }.to raise_error(Yell::LoggerNotFound)
-      end
-    end
-
-    context "default #adapter" do
-      subject { logger.adapters.instance_variable_get(:@collection) }
-
-      its(:size) { should == 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 set the name correctly" do
-      expect(logger.name).to eq(name)
-    end
-
-    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
-      expect(Yell::Adapters::File).to(
-        receive(:new).with(filename: filename).and_call_original
-      )
-
-      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
-      expect(Yell::Adapters::File).to(
-        receive(:new).with(filename: pathname).and_call_original
-      )
-
-      Yell::Logger.new(pathname)
-    end
-  end
-
-  context "initialize with a :stdout adapter" do
-    before do
-      expect(Yell::Adapters::Stdout).to receive(:new)
-    end
-
-    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 do
-      expect(Yell::Adapters::Stderr).to receive(:new)
-    end
-
-    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(:adapters) { logger.adapters.instance_variable_get(:@collection) }
-
-    context "with arity" do
-      let(:logger) do
-        Yell::Logger.new(level: level) { |l| l.adapter(:stdout) }
-      end
-
-      it "should pass the level correctly" do
-        expect(logger.level).to eq(level)
-      end
-
-      it "should pass the adapter correctly" do
-        expect(adapters.first).to be_instance_of(Yell::Adapters::Stdout)
-      end
-    end
-
-    context "without arity" do
-      let(:logger) do
-        Yell::Logger.new(level: level) { adapter(:stdout) }
-      end
-
-      it "should pass the level correctly" do
-        expect(logger.level).to eq(level)
-      end
-
-      it "should pass the adapter correctly" do
-        expect(adapters.first).to be_instance_of(Yell::Adapters::Stdout)
-      end
-    end
-  end
-
-  context "initialize with #adapters option" do
-    it "should set adapters in logger correctly" do
-      expect(Yell::Adapters::Stdout).to(
-        receive(:new).
-          and_call_original
-      )
-      expect(Yell::Adapters::Stderr).to(
-        receive(:new).
-          with(hash_including(level: :error)).
-          and_call_original
-      )
-
-      Yell::Logger.new(
-        adapters: [
-          :stdout,
-          {stderr: {level: :error}}
-        ]
-      )
-    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
-
-      expect(stdout.send(:stream)).to(
-        receive(:syswrite).with("#{__FILE__}, 7: info\n")
-      )
-      expect(stdout.send(:stream)).to(
-        receive(:syswrite).with("#{__FILE__}, 11: add\n")
-      )
-
-      factory.info
-      factory.add
-    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"]
-      logger.info %w[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
-      expect(stdout).to_not receive(:write)
-
-      logger.info "this should not be logged"
-    end
-
-    it "should pass a non-matching message to any adapter" do
-      expect(stdout).to receive(:write).with(kind_of(Yell::Event))
-
-      logger.info "that should be logged"
-    end
-  end
-
-end
-

data/spec/yell/repository_spec.rb

@@ -1,83 +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)" do
-        expect(subject).to eq(logger)
-      end
-    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
-        expect(Yell::LoggerNotFound).to(
-          receive(:new).with(String).and_call_original
-        )
-
-        expect {
-          Yell::Repository[String]
-        }.to raise_error(Yell::LoggerNotFound)
-      end
-
-      it "should return the logger" do
-        expect(Yell::Repository[Numeric]).to eq(logger)
-      end
-
-      it "should return the logger when superclass has it defined" do
-        expect(Yell::Repository[Integer]).to eq(logger)
-      end
-    end
-  end
-
-  context ".[]=" do
-    before { Yell::Repository[name] = logger }
-    it "should eq(logger)" do
-      expect(subject).to eq(logger)
-    end
-  end
-
-  context ".[]= with a named logger" do
-    let!(:logger) { Yell.new(:stdout, name: name) }
-    before { Yell::Repository[name] = logger }
-
-    it "should eq(logger)" do
-      expect(subject).to eq(logger)
-    end
-  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
-      expect(Yell::Repository[name]).to eq(logger)
-      expect(Yell::Repository[other]).to eq(logger)
-    end
-  end
-
-  context "loggers" do
-    let(:loggers) { { name => logger } }
-    subject { Yell::Repository.loggers }
-    before { Yell::Repository[name] = logger }
-
-    it "should eq(loggers)" do
-      expect(subject).to eq(loggers)
-    end
-  end
-
-end
-

data/spec/yell/silencer_spec.rb

@@ -1,38 +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 "#call" do
-    let(:silencer) { Yell::Silencer.new(/this/) }
-
-    it "should reject messages that match any pattern" do
-      expect(silencer.call("this")).to eq([])
-      expect(silencer.call("that")).to eq(["that"])
-      expect(silencer.call("this", "that")).to eq(["that"])
-    end
-  end
-
-end
-

data/spec/yell_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Yell do
-  let( :logger ) { Yell.new }
-
-  subject { logger }
-
-  it "should be_kind_of Yell::Logger" do
-    expect(subject).to be_a_kind_of(Yell::Logger)
-  end
-
-  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" do
-      expect(subject).to be_a_kind_of(Yell::Level)
-    end
-  end
-
-  context ".format" do
-    subject { Yell.format( "%m" ) }
-    it "should be_kind_of Yell::Formatter" do
-      expect(subject).to be_a_kind_of(Yell::Formatter)
-    end
-  end
-
-  context ".load!" do
-    subject { Yell.load!('yell.yml') }
-
-    before do
-      expect(Yell::Configuration).to(
-        receive(:load!).with('yell.yml') { {} }
-      )
-    end
-
-    it "should be_kind_of Yell::Logger" do
-      expect(subject).to be_a_kind_of(Yell::Logger)
-    end
-  end
-
-  context ".[]" do
-    let(:name) { 'test' }
-
-    it "should delegate to the repository" do
-      expect(Yell::Repository).to receive(:[]).with(name)
-
-      Yell[name]
-    end
-  end
-
-  context ".[]=" do
-    let(:name) { 'test' }
-
-    it "should delegate to the repository" do
-      expect(Yell::Repository).to(
-        receive(:[]=).with(name, logger).and_call_original
-      )
-
-      Yell[name] = logger
-    end
-  end
-
-  context ".env" do
-    subject { Yell.env }
-
-    it "should default to YELL_ENV" do
-      expect(subject).to eq('test')
-    end
-
-    context "fallback to RACK_ENV" do
-      before do
-        expect(ENV).to receive(:key?).with('YELL_ENV') { false }
-        expect(ENV).to receive(:key?).with('RACK_ENV') { true }
-
-        ENV['RACK_ENV'] = 'rack'
-      end
-
-      after { ENV.delete 'RACK_ENV' }
-
-      it "should == 'rack'" do
-        expect(subject).to eq('rack')
-      end
-    end
-
-    context "fallback to RAILS_ENV" do
-      before do
-        expect(ENV).to receive(:key?).with('YELL_ENV') { false }
-        expect(ENV).to receive(:key?).with('RACK_ENV') { false }
-        expect(ENV).to receive(:key?).with('RAILS_ENV') { true }
-
-        ENV['RAILS_ENV'] = 'rails'
-      end
-
-      after { ENV.delete 'RAILS_ENV' }
-
-      it "should == 'rails'" do
-        expect(subject).to eq('rails')
-      end
-    end
-
-    context "fallback to development" do
-      before do
-        expect(ENV).to receive(:key?).with('YELL_ENV') { false }
-        expect(ENV).to receive(:key?).with('RACK_ENV') { false }
-        expect(ENV).to receive(:key?).with('RAILS_ENV') { false }
-      end
-
-      it "should == 'development'" do
-        expect(subject).to eq('development')
-      end
-    end
-  end
-
-end
-