uniform_notifier 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8da3ce2873d3a8815e73e2949d20a318af6bf0d
-  data.tar.gz: 31bda16f462a5532493f63e74bb1b6a0a25a8778
+  metadata.gz: ce5c6778339ac98c3683322370c55b36e2e0f6d8
+  data.tar.gz: 2c10528a49539b46b7cdfbde658d5032e04ccffb
 SHA512:
-  metadata.gz: 62004481c5550047776f977309ba8cd192ca4e6c4335a3fe5a4682f9799040bce5fd3bf7b9ea32a4c1b845d2c039ee42f308360729c4052a1830f3d5c651f25c
-  data.tar.gz: a46b36763d83f32babe56f6e35b6547e4fdc5ab0d66517a7474c47f2e52972393a1c54e0559f990063ab4bc33c1e72ebf25bbcdd0fb1cc27c7382300b4198642
+  metadata.gz: bdff272e464293c384f81eb736b0e1d639293ae84b97c3212cff43f8ea5e150f43095f5f4efd055c57c50eb9be4e9d664d75efcf4b3d07d16083b058cf65e335
+  data.tar.gz: 0918ca02b1d871578e5cd5c45bb0037553ef7739adcbdd73d4655dad8d796290a0890e38de0fe1168c57af2dce392d458ab998507141a3ed46ed1c1cdea466a4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Next Release
 
+## 1.10.0 (01/06/2016)
+
+* Add honeybadger notifier
+* Eliminate ruby warnings
+
 ## 1.9.0 (04/19/2015)
 
 * Add `UniformNotifier::AVAILABLE_NOTIFIERS` constant

data/README.md

@@ -1,6 +1,6 @@
 # UniformNotifier
 
-uniform_notifier is extracted from [bullet][0], it gives you the ability to send notification through rails logger, customized logger, javascript alert, javascript console, growl, xmpp and airbrake.
+uniform_notifier is extracted from [bullet][0], it gives you the ability to send notification through rails logger, customized logger, javascript alert, javascript console, growl, xmpp, airbrake and honeybadger.
 
 ## Install
 
@@ -24,6 +24,10 @@ if you want to notify by airbrake, you should install airbrake first
 
     gem install airbrake
 
+if you want to notify by Honeybadger, you should install honeybadger first
+
+    gem install honeybadger
+
 if you want to notify by rollbar, you should install rollbar first
 
     gem install rollbar
@@ -40,7 +44,7 @@ if you want to notify by slack, you should install slack-notifier first
 
     gem "uniform_notifier"
 
-  you should add ruby-growl, ruby_gntp, xmpp4r, airbrake, bugsnag, slack-notifier gem if you want.
+  you should add ruby-growl, ruby_gntp, xmpp4r, airbrake, bugsnag, honeybadger, slack-notifier gem if you want.
 
 ## Usage
 
@@ -64,6 +68,14 @@ By default, all notifiers are disabled, you should enable them first.
     # airbrake with options
     UniformNotifier.airbrake = { :error_class => Exception }
 
+    # Honeybadger
+    #
+    # Reporting live data from development is disabled by default. Ensure
+    # that the `report_data` option is enabled via configuration.
+    UniformNotifier.honeybadger = true
+    # Honeybadger with options
+    UniformNotifier.honeybadger = { :error_class => 'Exception' }
+
     # rollbar
     UniformNotifier.rollbar = true
 

data/lib/uniform_notifier.rb

@@ -3,6 +3,7 @@ require 'uniform_notifier/errors'
 require 'uniform_notifier/javascript_alert'
 require 'uniform_notifier/javascript_console'
 require 'uniform_notifier/growl'
+require 'uniform_notifier/honeybadger'
 require 'uniform_notifier/xmpp'
 require 'uniform_notifier/rails_logger'
 require 'uniform_notifier/customized_logger'
@@ -13,37 +14,42 @@ require 'uniform_notifier/slack'
 require 'uniform_notifier/raise'
 
 class UniformNotifier
-  AVAILABLE_NOTIFIERS = [:alert, :console, :growl, :xmpp, :rails_logger, :customized_logger,
-                         :airbrake, :rollbar, :bugsnag, :slack, :raise]
+  AVAILABLE_NOTIFIERS = [:alert, :console, :growl, :honeybadger, :xmpp, :rails_logger,
+                         :customized_logger, :airbrake, :rollbar, :bugsnag, :slack, :raise]
 
-  NOTIFIERS = [JavascriptAlert, JavascriptConsole, Growl, Xmpp, RailsLogger, CustomizedLogger,
-               AirbrakeNotifier, RollbarNotifier, BugsnagNotifier, Raise, Slack]
+  NOTIFIERS = [JavascriptAlert, JavascriptConsole, Growl, HoneybadgerNotifier, Xmpp, RailsLogger,
+               CustomizedLogger, AirbrakeNotifier, RollbarNotifier, BugsnagNotifier, Raise, Slack]
 
   class NotificationError < StandardError; end
 
   class <<self
-    attr_accessor *AVAILABLE_NOTIFIERS
+    attr_accessor(*AVAILABLE_NOTIFIERS)
 
     def active_notifiers
       NOTIFIERS.select { |notifier| notifier.active? }
     end
 
+    undef :growl=
     def growl=(growl)
       UniformNotifier::Growl.setup_connection(growl)
     end
 
+    undef :xmpp=
     def xmpp=(xmpp)
       UniformNotifier::Xmpp.setup_connection(xmpp)
     end
 
+    undef :customized_logger=
     def customized_logger=(logdev)
       UniformNotifier::CustomizedLogger.setup(logdev)
     end
 
+    undef :slack=
     def slack=(slack)
       UniformNotifier::Slack.setup_connection(slack)
     end
 
+    undef :raise=
     def raise=(exception_class)
       UniformNotifier::Raise.setup_connection(exception_class)
     end

data/lib/uniform_notifier/growl.rb

@@ -71,5 +71,5 @@ class UniformNotifier
                         })
         end
       end
-    end
   end
+end

data/lib/uniform_notifier/honeybadger.rb

@@ -0,0 +1,21 @@
+class UniformNotifier
+  class HoneybadgerNotifier < Base
+    def self.active?
+      !!UniformNotifier.honeybadger
+    end
+
+    protected
+
+    def self._out_of_channel_notify(data)
+      message = data.values.compact.join("\n")
+
+      opt = {}
+      if UniformNotifier.honeybadger.is_a?(Hash)
+        opt = UniformNotifier.honeybadger
+      end
+
+      exception = Exception.new(message)
+      Honeybadger.notify(exception, opt)
+    end
+  end
+end

data/lib/uniform_notifier/version.rb

@@ -1,3 +1,3 @@
 class UniformNotifier
-  VERSION = "1.9.0"
+  VERSION = "1.10.0"
 end

data/spec/uniform_notifier/airbrake_spec.rb

@@ -4,20 +4,20 @@ class Airbrake
   # mock Airbrake
 end
 
-describe UniformNotifier::AirbrakeNotifier do
+RSpec.describe UniformNotifier::AirbrakeNotifier do
   it "should not notify airbrake" do
-    UniformNotifier::AirbrakeNotifier.out_of_channel_notify(:title => "notify airbrake").should be_nil
+    expect(UniformNotifier::AirbrakeNotifier.out_of_channel_notify(:title => "notify airbrake")).to be_nil
   end
 
   it "should notify airbrake" do
-    Airbrake.should_receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), {})
+    expect(Airbrake).to receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), {})
 
     UniformNotifier.airbrake = true
     UniformNotifier::AirbrakeNotifier.out_of_channel_notify(:title => "notify airbrake")
   end
 
   it "should notify airbrake" do
-    Airbrake.should_receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), :foo => :bar)
+    expect(Airbrake).to receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), :foo => :bar)
 
     UniformNotifier.airbrake = { :foo => :bar }
     UniformNotifier::AirbrakeNotifier.out_of_channel_notify("notify airbrake")

data/spec/uniform_notifier/base_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe UniformNotifier::Base do
+RSpec.describe UniformNotifier::Base do
   context "#inline_channel_notify" do
     before do
-      UniformNotifier::Base.stub(:active?).and_return(true)
+      allow(UniformNotifier::Base).to receive(:active?).and_return(true)
     end
     it "should keep the compatibility" do
-      UniformNotifier::Base.should_receive(:_inline_notify).once.with(:title => "something")
+      expect(UniformNotifier::Base).to receive(:_inline_notify).once.with(:title => "something")
       UniformNotifier::Base.inline_notify("something")
     end
   end
   context "#out_of_channel_notify" do
     before do
-      UniformNotifier::Base.stub(:active?).and_return(true)
+      allow(UniformNotifier::Base).to receive(:active?).and_return(true)
     end
     it "should keep the compatibility" do
-      UniformNotifier::Base.should_receive(:_out_of_channel_notify).once.with(:title => "something")
+      expect(UniformNotifier::Base).to receive(:_out_of_channel_notify).once.with(:title => "something")
       UniformNotifier::Base.out_of_channel_notify("something")
     end
   end

data/spec/uniform_notifier/bugsnag_spec.rb

@@ -4,24 +4,24 @@ class Bugsnag
   # mock Bugsnag
 end
 
-describe UniformNotifier::BugsnagNotifier do
+RSpec.describe UniformNotifier::BugsnagNotifier do
   let(:notification_data) { {} }
   it "should not notify bugsnag" do
-    Bugsnag.should_not_receive(:notify)
+    expect(Bugsnag).not_to receive(:notify)
     UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
   end
   context "with string notification" do
     let(:notification_data) { {:user => 'user', :title => 'notify bugsnag', :url => 'URL', body: 'something'} }
 
     it "should notify bugsnag" do
-      Bugsnag.should_receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :grouping_hash => notification_data[:body], :notification => notification_data)
+      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :grouping_hash => notification_data[:body], :notification => notification_data)
 
       UniformNotifier.bugsnag = true
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
 
     it "should notify bugsnag with option" do
-      Bugsnag.should_receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :foo => :bar, :grouping_hash => notification_data[:body], :notification => notification_data)
+      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :foo => :bar, :grouping_hash => notification_data[:body], :notification => notification_data)
 
       UniformNotifier.bugsnag = { :foo => :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
@@ -31,14 +31,14 @@ describe UniformNotifier::BugsnagNotifier do
     let(:notification_data) { "notify bugsnag" }
 
     it "should notify bugsnag" do
-      Bugsnag.should_receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
 
       UniformNotifier.bugsnag = true
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
 
     it "should notify bugsnag with option" do
-      Bugsnag.should_receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :foo => :bar, :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :foo => :bar, :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
 
       UniformNotifier.bugsnag = { :foo => :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
@@ -46,9 +46,9 @@ describe UniformNotifier::BugsnagNotifier do
   end
 
   it "should notify bugsnag with correct backtrace" do
-    Bugsnag.should_receive(:notify) do |error|
-      error.should be_a UniformNotifier::Exception
-      error.backtrace.should eq ["bugsnag spec test"]
+    expect(Bugsnag).to receive(:notify) do |error|
+      expect(error).to be_a UniformNotifier::Exception
+      expect(error.backtrace).to eq ["bugsnag spec test"]
     end
     UniformNotifier.bugsnag = true
     UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ["bugsnag spec test"])

data/spec/uniform_notifier/customized_logger_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe UniformNotifier::CustomizedLogger do
+RSpec.describe UniformNotifier::CustomizedLogger do
   it "should not notify to customized logger" do
-    UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger").should be_nil
+    expect(UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")).to be_nil
   end
 
   it "should notify to customized logger" do
@@ -10,12 +10,12 @@ describe UniformNotifier::CustomizedLogger do
     logger.sync = true
 
     now = Time.now
-    Time.stub(:now).and_return(now)
+    allow(Time).to receive(:now).and_return(now)
     UniformNotifier.customized_logger = logger
     UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")
 
     logger.seek(0)
-    logger.read.should == "#{now.strftime("%Y-%m-%d %H:%M:%S")}[WARN] notify rails logger"
+    expect(logger.read).to eq "#{now.strftime("%Y-%m-%d %H:%M:%S")}[WARN] notify rails logger"
 
     File.delete('test.log')
   end

data/spec/uniform_notifier/growl_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
-describe UniformNotifier::Growl do
+RSpec.describe UniformNotifier::Growl do
 
   it "should not notify growl" do
-    UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl').should be_nil
+    expect(UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl')).to be_nil
   end
 
   it "should notify growl without password" do
     growl = double('growl', :is_a? => true)
-    Growl.should_receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
-    growl.should_receive(:add_notification).with('uniform_notifier')
-    growl.should_receive(:password=).with(nil)
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl without password').ordered
+    expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
+    expect(growl).to receive(:add_notification).with('uniform_notifier')
+    expect(growl).to receive(:password=).with(nil)
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl without password').ordered
 
     UniformNotifier.growl = true
     UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl without password')
@@ -20,11 +20,11 @@ describe UniformNotifier::Growl do
 
   it "should notify growl with password" do
     growl = double('growl', :is_a? => true)
-    Growl.should_receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
-    growl.should_receive(:add_notification).with('uniform_notifier')
-    growl.should_receive(:password=).with('123456')
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
+    expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
+    expect(growl).to receive(:add_notification).with('uniform_notifier')
+    expect(growl).to receive(:password=).with('123456')
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
 
     UniformNotifier.growl = { :password => '123456' }
     UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')
@@ -32,11 +32,11 @@ describe UniformNotifier::Growl do
 
   it "should notify growl with host" do
     growl = double('growl', :is_a? => true)
-    Growl.should_receive(:new).with('10.10.156.17', 'uniform_notifier').and_return(growl)
-    growl.should_receive(:add_notification).with('uniform_notifier')
-    growl.should_receive(:password=).with('123456')
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
+    expect(Growl).to receive(:new).with('10.10.156.17', 'uniform_notifier').and_return(growl)
+    expect(growl).to receive(:add_notification).with('uniform_notifier')
+    expect(growl).to receive(:password=).with('123456')
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
 
     UniformNotifier.growl = { :password => '123456', :host => '10.10.156.17' }
     UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')
@@ -44,11 +44,11 @@ describe UniformNotifier::Growl do
 
   it "should notify growl with quiet" do
     growl = double('growl', :is_a? => true)
-    Growl.should_receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
-    growl.should_receive(:add_notification).with('uniform_notifier')
-    growl.should_receive(:password=).with('123456')
-    growl.should_not_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on')
-    growl.should_receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password')
+    expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
+    expect(growl).to receive(:add_notification).with('uniform_notifier')
+    expect(growl).to receive(:password=).with('123456')
+    expect(growl).not_to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on')
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password')
 
     UniformNotifier.growl = { :password => '123456', :quiet => true }
     UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')

data/spec/uniform_notifier/honeybadger_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+class Honeybadger
+  # mock Honeybadger
+end
+
+RSpec.describe UniformNotifier::HoneybadgerNotifier do
+  it "should not notify honeybadger" do
+    expect(UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(:title => "notify honeybadger")).to be_nil
+  end
+
+  it "should notify honeybadger" do
+    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new("notify honeybadger"), {})
+
+    UniformNotifier.honeybadger = true
+    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(:title => "notify honeybadger")
+  end
+
+  it "should notify honeybadger" do
+    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new("notify honeybadger"), :foo => :bar)
+
+    UniformNotifier.honeybadger = { :foo => :bar }
+    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify("notify honeybadger")
+  end
+end

data/spec/uniform_notifier/javascript_alert_spec.rb

@@ -1,13 +1,13 @@
 require "spec_helper"
 
-describe UniformNotifier::JavascriptAlert do
+RSpec.describe UniformNotifier::JavascriptAlert do
   it "should not notify message" do
-    UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!").should be_nil
+    expect(UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!")).to be_nil
   end
 
   it "should notify message" do
     UniformNotifier.alert = true
-    UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!").should == <<-CODE
+    expect(UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!")).to eq <<-CODE
 <script type="text/javascript">/*<![CDATA[*/
 alert( "javascript alert!" );
 /*]]>*/</script>

data/spec/uniform_notifier/javascript_console_spec.rb

@@ -1,13 +1,13 @@
 require "spec_helper"
 
-describe UniformNotifier::JavascriptConsole do
+RSpec.describe UniformNotifier::JavascriptConsole do
   it "should not notify message" do
-    UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!").should be_nil
+    expect(UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!")).to be_nil
   end
 
   it "should notify message" do
     UniformNotifier.console = true
-    UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!").should == <<-CODE
+    expect(UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!")).to eq <<-CODE
 <script type="text/javascript">/*<![CDATA[*/
 if (typeof(console) !== 'undefined' && console.log) {
   if (console.groupCollapsed && console.groupEnd) {

data/spec/uniform_notifier/rails_logger_spec.rb

@@ -4,15 +4,15 @@ class Rails
   # mock Rails
 end
 
-describe UniformNotifier::RailsLogger do
+RSpec.describe UniformNotifier::RailsLogger do
   it "should not notify rails logger" do
-    UniformNotifier::RailsLogger.out_of_channel_notify(:title => "notify rails logger").should be_nil
+    expect(UniformNotifier::RailsLogger.out_of_channel_notify(:title => "notify rails logger")).to be_nil
   end
 
   it "should notify rails logger" do
     logger = double("logger")
-    Rails.should_receive(:logger).and_return(logger)
-    logger.should_receive(:warn).with("notify rails logger")
+    expect(Rails).to receive(:logger).and_return(logger)
+    expect(logger).to receive(:warn).with("notify rails logger")
 
     UniformNotifier.rails_logger = true
     UniformNotifier::RailsLogger.out_of_channel_notify(:title => "notify rails logger")

data/spec/uniform_notifier/raise_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe UniformNotifier::Raise do
+RSpec.describe UniformNotifier::Raise do
   it "should not notify message" do
-    UniformNotifier::Raise.out_of_channel_notify(:title => "notification").should be_nil
+    expect(UniformNotifier::Raise.out_of_channel_notify(:title => "notification")).to be_nil
   end
 
   it "should raise error of the default class" do

data/spec/uniform_notifier/rollbar_spec.rb

@@ -4,13 +4,13 @@ class Rollbar
   # mock Rollbar
 end
 
-describe UniformNotifier::RollbarNotifier do
+RSpec.describe UniformNotifier::RollbarNotifier do
   it "should not notify rollbar" do
-    UniformNotifier::RollbarNotifier.out_of_channel_notify(:title => "notify rollbar").should be_nil
+    expect(UniformNotifier::RollbarNotifier.out_of_channel_notify(:title => "notify rollbar")).to be_nil
   end
 
   it "should notify rollbar" do
-    Rollbar.should_receive(:info).with(UniformNotifier::Exception.new("notify rollbar"))
+    expect(Rollbar).to receive(:info).with(UniformNotifier::Exception.new("notify rollbar"))
 
     UniformNotifier.rollbar = true
     UniformNotifier::RollbarNotifier.out_of_channel_notify(:title => "notify rollbar")

data/spec/uniform_notifier/slack_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe UniformNotifier::Slack do
+RSpec.describe UniformNotifier::Slack do
   context 'not enabled' do
     it 'should not notify slack' do
       expect_any_instance_of(Slack::Notifier).to_not receive(:ping)
@@ -39,7 +39,7 @@ describe UniformNotifier::Slack do
   end
 
   context 'properly configured' do
-    before(:each) do
+    before(:example) do
       @message = 'notify slack'
       allow_any_instance_of(Slack::Notifier).to receive(:ping).and_return(@message)
     end

data/spec/uniform_notifier/xmpp_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
-describe UniformNotifier::Xmpp do
+RSpec.describe UniformNotifier::Xmpp do
   it "should not notify xmpp" do
-    UniformNotifier::Xmpp.out_of_channel_notify(:title => "notify xmpp").should be_nil
+    expect(UniformNotifier::Xmpp.out_of_channel_notify(:title => "notify xmpp")).to be_nil
   end
 
   it "should notify xmpp without online status" do
     jid = double("jid")
     xmpp = double("xmpp")
-    Jabber::JID.should_receive(:new).with('from@gmail.com').and_return(jid)
-    Jabber::Client.should_receive(:new).with(jid).and_return(xmpp)
-    xmpp.should_receive(:connect)
-    xmpp.should_receive(:auth).with('123456')
+    expect(Jabber::JID).to receive(:new).with('from@gmail.com').and_return(jid)
+    expect(Jabber::Client).to receive(:new).with(jid).and_return(xmpp)
+    expect(xmpp).to receive(:connect)
+    expect(xmpp).to receive(:auth).with('123456')
 
     message = double("message")
-    Jabber::Message.should_receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
-    message.should_receive(:set_type).with(:normal).and_return(message)
-    message.should_receive(:set_subject).with('Uniform Notifier').and_return(message)
-    xmpp.should_receive(:send).with(message)
+    expect(Jabber::Message).to receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
+    expect(message).to receive(:set_type).with(:normal).and_return(message)
+    expect(message).to receive(:set_subject).with('Uniform Notifier').and_return(message)
+    expect(xmpp).to receive(:send).with(message)
 
     UniformNotifier.xmpp = {:account => 'from@gmail.com', :password => '123456', :receiver => 'to@gmail.com', :show_online_status => false}
     UniformNotifier::Xmpp.out_of_channel_notify(:title => 'notify xmpp')
@@ -26,23 +26,23 @@ describe UniformNotifier::Xmpp do
   it "should notify xmpp with online status" do
     jid = double("jid")
     xmpp = double("xmpp")
-    Jabber::JID.should_receive(:new).with('from@gmail.com').and_return(jid)
-    Jabber::Client.should_receive(:new).with(jid).and_return(xmpp)
-    xmpp.should_receive(:connect)
-    xmpp.should_receive(:auth).with('123456')
+    expect(Jabber::JID).to receive(:new).with('from@gmail.com').and_return(jid)
+    expect(Jabber::Client).to receive(:new).with(jid).and_return(xmpp)
+    expect(xmpp).to receive(:connect)
+    expect(xmpp).to receive(:auth).with('123456')
 
     presence = double("presence")
     now = Time.now
-    Time.stub(:now).and_return(now)
-    Jabber::Presence.should_receive(:new).and_return(presence)
-    presence.should_receive(:set_status).with("Uniform Notifier started on #{now}").and_return(presence)
-    xmpp.should_receive(:send).with(presence)
+    allow(Time).to receive(:now).and_return(now)
+    expect(Jabber::Presence).to receive(:new).and_return(presence)
+    expect(presence).to receive(:set_status).with("Uniform Notifier started on #{now}").and_return(presence)
+    expect(xmpp).to receive(:send).with(presence)
 
     message = double("message")
-    Jabber::Message.should_receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
-    message.should_receive(:set_type).with(:normal).and_return(message)
-    message.should_receive(:set_subject).with('Uniform Notifier').and_return(message)
-    xmpp.should_receive(:send).with(message)
+    expect(Jabber::Message).to receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
+    expect(message).to receive(:set_type).with(:normal).and_return(message)
+    expect(message).to receive(:set_subject).with('Uniform Notifier').and_return(message)
+    expect(xmpp).to receive(:send).with(message)
 
     UniformNotifier.xmpp = {:account => 'from@gmail.com', :password => '123456', :receiver => 'to@gmail.com', :show_online_status => true}
     UniformNotifier::Xmpp.out_of_channel_notify(:title => 'notify xmpp')

data/uniform_notifier.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://rubygems.org/gems/uniform_notifier"
   s.summary     = %q{uniform notifier for rails logger, customized logger, javascript alert, javascript console, growl and xmpp}
   s.description = %q{uniform notifier for rails logger, customized logger, javascript alert, javascript console, growl and xmpp}
+  s.license     = 'MIT'
 
   s.rubyforge_project = "uniform_notifier"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uniform_notifier
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2016-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-growl
@@ -102,6 +102,7 @@ files:
 - lib/uniform_notifier/customized_logger.rb
 - lib/uniform_notifier/errors.rb
 - lib/uniform_notifier/growl.rb
+- lib/uniform_notifier/honeybadger.rb
 - lib/uniform_notifier/javascript_alert.rb
 - lib/uniform_notifier/javascript_console.rb
 - lib/uniform_notifier/rails_logger.rb
@@ -116,6 +117,7 @@ files:
 - spec/uniform_notifier/bugsnag_spec.rb
 - spec/uniform_notifier/customized_logger_spec.rb
 - spec/uniform_notifier/growl_spec.rb
+- spec/uniform_notifier/honeybadger_spec.rb
 - spec/uniform_notifier/javascript_alert_spec.rb
 - spec/uniform_notifier/javascript_console_spec.rb
 - spec/uniform_notifier/rails_logger_spec.rb
@@ -125,7 +127,8 @@ files:
 - spec/uniform_notifier/xmpp_spec.rb
 - uniform_notifier.gemspec
 homepage: http://rubygems.org/gems/uniform_notifier
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -143,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: uniform_notifier
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: uniform notifier for rails logger, customized logger, javascript alert, javascript
@@ -155,6 +158,7 @@ test_files:
 - spec/uniform_notifier/bugsnag_spec.rb
 - spec/uniform_notifier/customized_logger_spec.rb
 - spec/uniform_notifier/growl_spec.rb
+- spec/uniform_notifier/honeybadger_spec.rb
 - spec/uniform_notifier/javascript_alert_spec.rb
 - spec/uniform_notifier/javascript_console_spec.rb
 - spec/uniform_notifier/rails_logger_spec.rb