uniform_notifier 1.11.0 → 1.12.0

data/lib/uniform_notifier/rails_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class RailsLogger < Base
     def self.active?
@@ -6,7 +8,7 @@ class UniformNotifier
 
     protected
 
-    def self._out_of_channel_notify( data )
+    def self._out_of_channel_notify(data)
       message = data.values.compact.join("\n")
 
       Rails.logger.warn message

data/lib/uniform_notifier/raise.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class Raise < Base
     def self.active?
@@ -10,7 +12,7 @@ class UniformNotifier
 
     protected
 
-    def self._out_of_channel_notify( data )
+    def self._out_of_channel_notify(data)
       message = data.values.compact.join("\n")
 
       raise @exception_class, message

data/lib/uniform_notifier/rollbar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class RollbarNotifier < Base
     def self.active?

data/lib/uniform_notifier/sentry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class SentryNotifier < Base
     def self.active?

data/lib/uniform_notifier/slack.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class Slack < Base
-    POSSIBLE_OPTIONS = [:username, :channel]
+    POSSIBLE_OPTIONS = %i[username channel].freeze
 
     @slack = nil
 
@@ -9,7 +11,7 @@ class UniformNotifier
         @slack
       end
 
-      def setup_connection(config={})
+      def setup_connection(config = {})
         webhook_url, options = parse_config(config)
         fail_connection('webhook_url required for Slack notification') unless webhook_url
 
@@ -22,30 +24,29 @@ class UniformNotifier
 
       protected
 
-        def _out_of_channel_notify(data)
-          message = data.values.compact.join("\n")
-          notify(message)
-        end
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
+        notify(message)
+      end
 
       private
 
-        def fail_connection(message)
-          @slack = nil
-          raise NotificationError.new(message)
-        end
-
-        def notify(message)
-          @slack.ping message
-        end
+      def fail_connection(message)
+        @slack = nil
+        raise NotificationError, message
+      end
 
-        def parse_config(config)
-          options = config.select do |name, value|
-            POSSIBLE_OPTIONS.include?(name) && !value.nil?
-          end
+      def notify(message)
+        @slack.ping message
+      end
 
-          return config[:webhook_url], options
+      def parse_config(config)
+        options = config.select do |name, value|
+          POSSIBLE_OPTIONS.include?(name) && !value.nil?
         end
 
+        [config[:webhook_url], options]
+      end
     end
   end
 end

data/lib/uniform_notifier/terminal_notifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class UniformNotifier
+  class TerminalNotifier < Base
+    def self.active?
+      !!UniformNotifier.terminal_notifier
+    end
+
+    protected
+
+    def self._out_of_channel_notify(data)
+      unless defined?(::TerminalNotifier)
+        begin
+          require 'terminal-notifier'
+        rescue LoadError
+          raise NotificationError, 'You must install the terminal-notifier gem to use terminal_notifier: `gem install terminal-notifier`'
+        end
+      end
+
+      ::TerminalNotifier.notify(data[:body], title: data[:title])
+    end
+  end
+end

data/lib/uniform_notifier/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
-  VERSION = "1.11.0"
+  VERSION = '1.12.0'
 end

data/lib/uniform_notifier/xmpp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class UniformNotifier
   class Xmpp < Base
     @receiver = nil
@@ -8,7 +10,7 @@ class UniformNotifier
       @xmpp
     end
 
-    def self.setup_connection( xmpp_information )
+    def self.setup_connection(xmpp_information)
       return unless xmpp_information
 
       require 'xmpp4r'
@@ -23,36 +25,37 @@ class UniformNotifier
       connect if @stay_connected
     rescue LoadError
       @xmpp = nil
-      raise NotificationError.new( 'You must install the xmpp4r gem to use XMPP notification: `gem install xmpp4r`' )
+      raise NotificationError, 'You must install the xmpp4r gem to use XMPP notification: `gem install xmpp4r`'
     end
 
     protected
 
-    def self._out_of_channel_notify( data )
+    def self._out_of_channel_notify(data)
       message = data.values.compact.join("\n")
 
-      notify( message )
+      notify(message)
     end
 
     private
-      def self.connect
-        jid = Jabber::JID.new( @account )
-        @xmpp = Jabber::Client.new( jid )
-        @xmpp.connect
-        @xmpp.auth( @password )
-        @xmpp.send( presence_status ) if @show_online_status
-      end
-
-      def self.notify( message )
-        connect unless @stay_connected
-        message = Jabber::Message.new( @receiver, message ).
-                                  set_type( :normal ).
-                                  set_subject( 'Uniform Notifier' )
-        @xmpp.send( message )
-      end
-
-      def self.presence_status
-        Jabber::Presence.new.set_status( "Uniform Notifier started on #{Time.now}" )
-      end
+
+    def self.connect
+      jid = Jabber::JID.new(@account)
+      @xmpp = Jabber::Client.new(jid)
+      @xmpp.connect
+      @xmpp.auth(@password)
+      @xmpp.send(presence_status) if @show_online_status
+    end
+
+    def self.notify(message)
+      connect unless @stay_connected
+      message = Jabber::Message.new(@receiver, message)
+                               .set_type(:normal)
+                               .set_subject('Uniform Notifier')
+      @xmpp.send(message)
+    end
+
+    def self.presence_status
+      Jabber::Presence.new.set_status("Uniform Notifier started on #{Time.now}")
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+# frozen_string_literal: true
 
-require "uniform_notifier"
-require "ruby-growl"
-require "xmpp4r"
-require "slack-notifier"
-require "rspec"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'uniform_notifier'
+require 'ruby-growl'
+require 'xmpp4r'
+require 'slack-notifier'
+require 'rspec'

data/spec/uniform_notifier/airbrake_spec.rb

@@ -1,25 +1,27 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Airbrake
   # mock Airbrake
 end
 
 RSpec.describe UniformNotifier::AirbrakeNotifier do
-  it "should not notify airbrake" do
-    expect(UniformNotifier::AirbrakeNotifier.out_of_channel_notify(:title => "notify airbrake")).to be_nil
+  it 'should not notify airbrake' do
+    expect(UniformNotifier::AirbrakeNotifier.out_of_channel_notify(title: 'notify airbrake')).to be_nil
   end
 
-  it "should notify airbrake" do
-    expect(Airbrake).to receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), {})
+  it 'should notify airbrake' do
+    expect(Airbrake).to receive(:notify).with(UniformNotifier::Exception.new('notify airbrake'), {})
 
     UniformNotifier.airbrake = true
-    UniformNotifier::AirbrakeNotifier.out_of_channel_notify(:title => "notify airbrake")
+    UniformNotifier::AirbrakeNotifier.out_of_channel_notify(title: 'notify airbrake')
   end
 
-  it "should notify airbrake" do
-    expect(Airbrake).to receive(:notify).with(UniformNotifier::Exception.new("notify airbrake"), :foo => :bar)
+  it 'should notify airbrake' do
+    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")
+    UniformNotifier.airbrake = { foo: :bar }
+    UniformNotifier::AirbrakeNotifier.out_of_channel_notify('notify airbrake')
   end
 end

data/spec/uniform_notifier/base_spec.rb

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

data/spec/uniform_notifier/bugsnag_spec.rb

@@ -1,4 +1,6 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Bugsnag
   # mock Bugsnag
@@ -6,51 +8,51 @@ end
 
 RSpec.describe UniformNotifier::BugsnagNotifier do
   let(:notification_data) { {} }
-  it "should not notify bugsnag" do
+  it 'should not notify bugsnag' do
     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'} }
+  context 'with string notification' do
+    let(:notification_data) { { user: 'user', title: 'notify bugsnag', url: 'URL', body: 'something' } }
 
-    it "should notify bugsnag" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :grouping_hash => notification_data[:body], :notification => notification_data)
+    it 'should notify bugsnag' do
+      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
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :foo => :bar, :grouping_hash => notification_data[:body], :notification => notification_data)
+    it 'should notify bugsnag with option' do
+      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.bugsnag = { foo: :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
   end
-  context "with hash notification" do
-    let(:notification_data) { "notify bugsnag" }
+  context 'with hash notification' do
+    let(:notification_data) { 'notify bugsnag' }
 
-    it "should notify bugsnag" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+    it 'should notify bugsnag' do
+      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
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :foo => :bar, :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+    it 'should notify bugsnag with option' do
+      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.bugsnag = { foo: :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
   end
 
-  it "should notify bugsnag with correct backtrace" do
+  it 'should notify bugsnag with correct backtrace' do
     expect(Bugsnag).to receive(:notify) do |error|
       expect(error).to be_a UniformNotifier::Exception
-      expect(error.backtrace).to eq ["bugsnag spec test"]
+      expect(error.backtrace).to eq ['bugsnag spec test']
     end
     UniformNotifier.bugsnag = true
-    UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ["bugsnag spec test"])
+    UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ['bugsnag spec test'])
   end
 end

data/spec/uniform_notifier/customized_logger_spec.rb

@@ -1,21 +1,23 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe UniformNotifier::CustomizedLogger do
-  it "should not notify to customized logger" do
-    expect(UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")).to be_nil
+  it 'should not notify to customized logger' do
+    expect(UniformNotifier::CustomizedLogger.out_of_channel_notify(title: 'notify rails logger')).to be_nil
   end
 
-  it "should notify to customized logger" do
-    logger = File.open( 'test.log', 'a+' )
+  it 'should notify to customized logger' do
+    logger = File.open('test.log', 'a+')
     logger.sync = true
 
     now = Time.now
     allow(Time).to receive(:now).and_return(now)
     UniformNotifier.customized_logger = logger
-    UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")
+    UniformNotifier::CustomizedLogger.out_of_channel_notify(title: 'notify rails logger')
 
     logger.seek(0)
-    expect(logger.read).to eq "#{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,13 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe UniformNotifier::Growl do
-
-  it "should not notify growl" do
-    expect(UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl')).to be_nil
+  it 'should not notify growl' do
+    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)
+  it 'should notify growl without password' do
+    growl = double('growl', is_a?: true)
     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)
@@ -15,42 +16,42 @@ RSpec.describe UniformNotifier::Growl do
     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')
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl without password')
   end
 
-  it "should notify growl with password" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with password' do
+    growl = double('growl', is_a?: true)
     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')
+    UniformNotifier.growl = { password: '123456' }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 
-  it "should notify growl with host" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with host' do
+    growl = double('growl', is_a?: true)
     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')
+    UniformNotifier.growl = { password: '123456', host: '10.10.156.17' }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 
-  it "should notify growl with quiet" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with quiet' do
+    growl = double('growl', is_a?: true)
     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')
+    UniformNotifier.growl = { password: '123456', quiet: true }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 end