uniform_notifier 1.14.0 → 1.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e0dc90eb392f340e5bcb87c74e7f5ff5abdfe056c2f9a477349ed21806c981c
-  data.tar.gz: da95631ac719cf684e878f377cd93ab1678ed6d5d18ba63c22b3f04d77224386
+  metadata.gz: b9fa5744a54e1bff245ab1f1b03974250a6a0880d63ba05b6594ada564bf4c87
+  data.tar.gz: ae4f6c59d2377f88f50419bcc1abe9215987a9b9c1d549b1323919d9f2d5841a
 SHA512:
-  metadata.gz: 73a4d1e31f1604646b28f703ab865b6644413e42d41096c5e983d7fbbb0ae8a6ea1b2d14c88ffea7c15007d431aebedefd948d4365e265a3f074efd166ccc3a6
-  data.tar.gz: '08c69d23ee80f460409ab2edd5949a7beff96799afc5aa5ea8adb89536969fb9c1defa096ac24a652551280ff0b1a8b86c85ddde5443c7ade8f04c459ee42a30'
+  metadata.gz: d739e807172146c2647ab96b122825efc3c033bc27dc3a27cf05c7d7e1c07bc2a273a15df6dd1f8574273663b30143b82cb997756c65a61c69c051c332c81dee
+  data.tar.gz: 785945370f105bacf35cc12b2d769a6d3038d4520df5f376e9d42cf055ea0959777431058c0f9f0f05bd1a2a823dcf2aaa929201d07122ab3aef3128732cda56

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Next Release
 
+# 1.14.1 (02/28/2021)
+
+* Fix uninitialized constant ``UniformNotifier::SentryNotifier::Raven`` error
+
 # 1.14.0 (02/26/2021)
 
 * Add AppSignal integration

data/lib/uniform_notifier.rb

@@ -55,7 +55,8 @@ class UniformNotifier
     TerminalNotifier
   ].freeze
 
-  class NotificationError < StandardError; end
+  class NotificationError < StandardError
+  end
 
   class << self
     attr_accessor(*AVAILABLE_NOTIFIERS)
@@ -64,27 +65,27 @@ class UniformNotifier
       NOTIFIERS.select(&:active?)
     end
 
-    undef :growl=
+    undef growl=
     def growl=(growl)
       UniformNotifier::Growl.setup_connection(growl)
     end
 
-    undef :xmpp=
+    undef xmpp=
     def xmpp=(xmpp)
       UniformNotifier::Xmpp.setup_connection(xmpp)
     end
 
-    undef :customized_logger=
+    undef customized_logger=
     def customized_logger=(logdev)
       UniformNotifier::CustomizedLogger.setup(logdev)
     end
 
-    undef :slack=
+    undef slack=
     def slack=(slack)
       UniformNotifier::Slack.setup_connection(slack)
     end
 
-    undef :raise=
+    undef raise=
     def raise=(exception_class)
       UniformNotifier::Raise.setup_connection(exception_class)
     end

data/lib/uniform_notifier/airbrake.rb

@@ -2,20 +2,22 @@
 
 class UniformNotifier
   class AirbrakeNotifier < Base
-    def self.active?
-      !!UniformNotifier.airbrake
-    end
+    class << self
+      def active?
+        !!UniformNotifier.airbrake
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      opt = {}
-      opt = UniformNotifier.airbrake if UniformNotifier.airbrake.is_a?(Hash)
+        opt = {}
+        opt = UniformNotifier.airbrake if UniformNotifier.airbrake.is_a?(Hash)
 
-      exception = Exception.new(message)
-      Airbrake.notify(exception, opt)
+        exception = Exception.new(message)
+        Airbrake.notify(exception, opt)
+      end
     end
   end
 end

data/lib/uniform_notifier/appsignal.rb

@@ -2,22 +2,24 @@
 
 class UniformNotifier
   class AppsignalNotifier < Base
-    def self.active?
-      !!UniformNotifier.appsignal
-    end
+    class << self
+      def active?
+        !!UniformNotifier.appsignal
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      opt = UniformNotifier.appsignal.is_a?(Hash) ? UniformNotifier.appsignal : {}
+      def _out_of_channel_notify(data)
+        opt = UniformNotifier.appsignal.is_a?(Hash) ? UniformNotifier.appsignal : {}
 
-      exception = Exception.new(data[:title])
-      exception.set_backtrace(data[:backtrace]) if data[:backtrace]
+        exception = Exception.new(data[:title])
+        exception.set_backtrace(data[:backtrace]) if data[:backtrace]
 
-      tags = opt.fetch(:tags, {}).merge(data.fetch(:tags, {}))
-      namespace = data[:namespace] || opt[:namespace]
+        tags = opt.fetch(:tags, {}).merge(data.fetch(:tags, {}))
+        namespace = data[:namespace] || opt[:namespace]
 
-      Appsignal.send_error(*[exception, tags, namespace].compact)
+        Appsignal.send_error(*[exception, tags, namespace].compact)
+      end
     end
   end
 end

data/lib/uniform_notifier/base.rb

@@ -2,43 +2,45 @@
 
 class UniformNotifier
   class Base
-    def self.active?
-      false
-    end
+    class << self
+      def active?
+        false
+      end
 
-    def self.inline_notify(data)
-      return unless active?
+      def inline_notify(data)
+        return unless active?
 
-      # For compatibility to the old protocol
-      data = { title: data } if data.is_a?(String)
+        # For compatibility to the old protocol
+        data = { title: data } if data.is_a?(String)
 
-      _inline_notify(data)
-    end
+        _inline_notify(data)
+      end
 
-    def self.out_of_channel_notify(data)
-      return unless active?
+      def out_of_channel_notify(data)
+        return unless active?
 
-      # For compatibility to the old protocol
-      data = { title: data } if data.is_a?(String)
+        # For compatibility to the old protocol
+        data = { title: data } if data.is_a?(String)
 
-      _out_of_channel_notify(data)
-    end
+        _out_of_channel_notify(data)
+      end
 
-    protected
+      protected
 
-    def self._inline_notify(data); end
+      def _inline_notify(data); end
 
-    def self._out_of_channel_notify(data); end
+      def _out_of_channel_notify(data); end
 
-    def self.wrap_js_association(code, attributes = {})
-      attributes = { type: 'text/javascript' }.merge(attributes || {})
-      attributes_string = attributes.map { |k, v| "#{k}=#{v.to_s.inspect}" }.join(' ')
+      def wrap_js_association(code, attributes = {})
+        attributes = { type: 'text/javascript' }.merge(attributes || {})
+        attributes_string = attributes.map { |k, v| "#{k}=#{v.to_s.inspect}" }.join(' ')
 
-      <<~CODE
-        <script #{attributes_string}>/*<![CDATA[*/
-        #{code}
-        /*]]>*/</script>
-      CODE
+        <<~CODE
+          <script #{attributes_string}>/*<![CDATA[*/
+          #{code}
+          /*]]>*/</script>
+        CODE
+      end
     end
   end
 end

data/lib/uniform_notifier/bugsnag.rb

@@ -2,19 +2,21 @@
 
 class UniformNotifier
   class BugsnagNotifier < Base
-    def self.active?
-      !!UniformNotifier.bugsnag
-    end
+    class << self
+      def active?
+        !!UniformNotifier.bugsnag
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      opt = {}
-      opt = UniformNotifier.bugsnag if UniformNotifier.bugsnag.is_a?(Hash)
+      def _out_of_channel_notify(data)
+        opt = {}
+        opt = UniformNotifier.bugsnag if UniformNotifier.bugsnag.is_a?(Hash)
 
-      exception = Exception.new(data[:title])
-      exception.set_backtrace(data[:backtrace]) if data[:backtrace]
-      Bugsnag.notify(exception, opt.merge(grouping_hash: data[:body] || data[:title], notification: data))
+        exception = Exception.new(data[:title])
+        exception.set_backtrace(data[:backtrace]) if data[:backtrace]
+        Bugsnag.notify(exception, opt.merge(grouping_hash: data[:body] || data[:title], notification: data))
+      end
     end
   end
 end

data/lib/uniform_notifier/customized_logger.rb

@@ -2,24 +2,26 @@
 
 class UniformNotifier
   class CustomizedLogger < Base
-    @logger = nil
+    class << self
+      @logger = nil
 
-    def self.active?
-      @logger
-    end
+      def active?
+        @logger
+      end
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
-      @logger.warn message
-    end
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
+        @logger.warn message
+      end
 
-    def self.setup(logdev)
-      require 'logger'
+      def setup(logdev)
+        require 'logger'
 
-      @logger = Logger.new(logdev)
+        @logger = Logger.new(logdev)
 
-      def @logger.format_message(severity, timestamp, _progname, msg)
-        "#{timestamp.strftime('%Y-%m-%d %H:%M:%S')}[#{severity}] #{msg}"
+        def @logger.format_message(severity, timestamp, _progname, msg)
+          "#{timestamp.strftime('%Y-%m-%d %H:%M:%S')}[#{severity}] #{msg}"
+        end
       end
     end
   end

data/lib/uniform_notifier/errors.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 class UniformNotifier
-  class Exception < RuntimeError; end
+  class Exception < RuntimeError
+  end
 end

data/lib/uniform_notifier/growl.rb

@@ -2,72 +2,74 @@
 
 class UniformNotifier
   class Growl < Base
-    @growl = nil
+    class << self
+      @growl = nil
 
-    def self.active?
-      @growl
-    end
+      def active?
+        @growl
+      end
 
-    def self.setup_connection(growl)
-      setup_connection_growl(growl)
-    rescue LoadError
-      begin
-        setup_connection_gntp(growl)
+      def setup_connection(growl)
+        setup_connection_growl(growl)
       rescue LoadError
-        @growl = nil
-        raise NotificationError,
-              'You must install the ruby-growl or the ruby_gntp gem to use Growl notification: `gem install ruby-growl` or `gem install ruby_gntp`'
+        begin
+          setup_connection_gntp(growl)
+        rescue LoadError
+          @growl = nil
+          raise NotificationError,
+                'You must install the ruby-growl or the ruby_gntp gem to use Growl notification: `gem install ruby-growl` or `gem install ruby_gntp`'
+        end
       end
-    end
 
-    def self.setup_connection_growl(growl)
-      return unless growl
+      def setup_connection_growl(growl)
+        return unless growl
 
-      require 'ruby-growl'
-      if growl.instance_of?(Hash)
-        @password = growl.include?(:password) ? growl[:password] : nil
-        @host = growl.include?(:host) ? growl[:host] : 'localhost'
+        require 'ruby-growl'
+        if growl.instance_of?(Hash)
+          @password = growl.include?(:password) ? growl[:password] : nil
+          @host = growl.include?(:host) ? growl[:host] : 'localhost'
+        end
+        @password ||= nil
+        @host ||= 'localhost'
+        @growl = ::Growl.new @host, 'uniform_notifier'
+        @growl.add_notification 'uniform_notifier'
+        @growl.password = @password
+
+        notify 'Uniform Notifier Growl has been turned on' if !growl.instance_of?(Hash) || !growl[:quiet]
       end
-      @password ||= nil
-      @host ||= 'localhost'
-      @growl = ::Growl.new @host, 'uniform_notifier'
-      @growl.add_notification 'uniform_notifier'
-      @growl.password = @password
 
-      notify 'Uniform Notifier Growl has been turned on' if !growl.instance_of?(Hash) || !growl[:quiet]
-    end
+      def setup_connection_gntp(growl)
+        return unless growl
 
-    def self.setup_connection_gntp(growl)
-      return unless growl
+        require 'ruby_gntp'
+        if growl.instance_of?(Hash)
+          @password = growl.include?(:password) ? growl[:password] : nil
+          @host = growl.include?(:host) ? growl[:host] : 'localhost'
+        end
+        @password ||= nil
+        @host ||= 'localhost'
+        @growl = GNTP.new('uniform_notifier', @host, @password, 23_053)
+        @growl.register(notifications: [{ name: 'uniform_notifier', enabled: true }])
 
-      require 'ruby_gntp'
-      if growl.instance_of?(Hash)
-        @password = growl.include?(:password) ? growl[:password] : nil
-        @host = growl.include?(:host) ? growl[:host] : 'localhost'
+        notify 'Uniform Notifier Growl has been turned on (using GNTP)' if !growl.instance_of?(Hash) || !growl[:quiet]
       end
-      @password ||= nil
-      @host ||= 'localhost'
-      @growl = GNTP.new('uniform_notifier', @host, @password, 23_053)
-      @growl.register(notifications: [{ name: 'uniform_notifier', enabled: true }])
 
-      notify 'Uniform Notifier Growl has been turned on (using GNTP)' if !growl.instance_of?(Hash) || !growl[:quiet]
-    end
-
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      notify(message)
-    end
+        notify(message)
+      end
 
-    private
+      private
 
-    def self.notify(message)
-      if defined?(::Growl) && @growl.is_a?(::Growl)
-        @growl.notify('uniform_notifier', 'Uniform Notifier', message)
-      elsif defined?(::GNTP) && @growl.is_a?(::GNTP)
-        @growl.notify(name: 'uniform_notifier', title: 'Uniform Notifier', text: message)
+      def notify(message)
+        if defined?(::Growl) && @growl.is_a?(::Growl)
+          @growl.notify('uniform_notifier', 'Uniform Notifier', message)
+        elsif defined?(::GNTP) && @growl.is_a?(::GNTP)
+          @growl.notify(name: 'uniform_notifier', title: 'Uniform Notifier', text: message)
+        end
       end
     end
   end

data/lib/uniform_notifier/honeybadger.rb

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

data/lib/uniform_notifier/javascript_alert.rb

@@ -2,18 +2,20 @@
 
 class UniformNotifier
   class JavascriptAlert < Base
-    def self.active?
-      !!UniformNotifier.alert
-    end
+    class << self
+      def active?
+        !!UniformNotifier.alert
+      end
 
-    protected
+      protected
 
-    def self._inline_notify(data)
-      message = data.values.compact.join("\n")
-      options = UniformNotifier.alert.is_a?(Hash) ? UniformNotifier.alert : {}
-      script_attributes = options[:attributes] || {}
+      def _inline_notify(data)
+        message = data.values.compact.join("\n")
+        options = UniformNotifier.alert.is_a?(Hash) ? UniformNotifier.alert : {}
+        script_attributes = options[:attributes] || {}
 
-      wrap_js_association "alert( #{message.inspect} );", script_attributes
+        wrap_js_association "alert( #{message.inspect} );", script_attributes
+      end
     end
   end
 end

data/lib/uniform_notifier/javascript_console.rb

@@ -2,30 +2,32 @@
 
 class UniformNotifier
   class JavascriptConsole < Base
-    def self.active?
-      !!UniformNotifier.console
-    end
+    class << self
+      def active?
+        !!UniformNotifier.console
+      end
 
-    protected
+      protected
 
-    def self._inline_notify(data)
-      message = data.values.compact.join("\n")
-      options = UniformNotifier.console.is_a?(Hash) ? UniformNotifier.console : {}
-      script_attributes = options[:attributes] || {}
+      def _inline_notify(data)
+        message = data.values.compact.join("\n")
+        options = UniformNotifier.console.is_a?(Hash) ? UniformNotifier.console : {}
+        script_attributes = options[:attributes] || {}
 
-      code = <<~CODE
-        if (typeof(console) !== 'undefined' && console.log) {
-          if (console.groupCollapsed && console.groupEnd) {
-            console.groupCollapsed(#{'Uniform Notifier'.inspect});
-            console.log(#{message.inspect});
-            console.groupEnd();
-          } else {
-            console.log(#{message.inspect});
+        code = <<~CODE
+          if (typeof(console) !== 'undefined' && console.log) {
+            if (console.groupCollapsed && console.groupEnd) {
+              console.groupCollapsed(#{'Uniform Notifier'.inspect});
+              console.log(#{message.inspect});
+              console.groupEnd();
+            } else {
+              console.log(#{message.inspect});
+            }
           }
-        }
-      CODE
+        CODE
 
-      wrap_js_association code, script_attributes
+        wrap_js_association code, script_attributes
+      end
     end
   end
 end

data/lib/uniform_notifier/rails_logger.rb

@@ -2,16 +2,18 @@
 
 class UniformNotifier
   class RailsLogger < Base
-    def self.active?
-      UniformNotifier.rails_logger
-    end
+    class << self
+      def active?
+        UniformNotifier.rails_logger
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      Rails.logger.warn message
+        Rails.logger.warn message
+      end
     end
   end
 end

data/lib/uniform_notifier/raise.rb

@@ -2,20 +2,22 @@
 
 class UniformNotifier
   class Raise < Base
-    def self.active?
-      defined?(@exception_class) ? @exception_class : false
-    end
+    class << self
+      def active?
+        defined?(@exception_class) ? @exception_class : false
+      end
 
-    def self.setup_connection(exception_class)
-      @exception_class = exception_class == true ? Exception : exception_class
-    end
+      def setup_connection(exception_class)
+        @exception_class = exception_class == true ? Exception : exception_class
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      raise @exception_class, message
+        raise @exception_class, message
+      end
     end
   end
 end

data/lib/uniform_notifier/rollbar.rb

@@ -4,20 +4,22 @@ class UniformNotifier
   class RollbarNotifier < Base
     DEFAULT_LEVEL = 'info'
 
-    def self.active?
-      !!UniformNotifier.rollbar
-    end
+    class << self
+      def active?
+        !!UniformNotifier.rollbar
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      exception = Exception.new(message)
-      level = UniformNotifier.rollbar.fetch(:level, DEFAULT_LEVEL) if UniformNotifier.rollbar.is_a?(Hash)
-      level ||= DEFAULT_LEVEL
+        exception = Exception.new(message)
+        level = UniformNotifier.rollbar.fetch(:level, DEFAULT_LEVEL) if UniformNotifier.rollbar.is_a?(Hash)
+        level ||= DEFAULT_LEVEL
 
-      Rollbar.log(level, exception)
+        Rollbar.log(level, exception)
+      end
     end
   end
 end

data/lib/uniform_notifier/sentry.rb

@@ -2,20 +2,22 @@
 
 class UniformNotifier
   class SentryNotifier < Base
-    def self.active?
-      !!UniformNotifier.sentry
-    end
+    class << self
+      def active?
+        !!UniformNotifier.sentry
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      opt = {}
-      opt = UniformNotifier.sentry if UniformNotifier.sentry.is_a?(Hash)
+        opt = {}
+        opt = UniformNotifier.sentry if UniformNotifier.sentry.is_a?(Hash)
 
-      exception = Exception.new(message)
-      Raven.capture_exception(exception, opt)
+        exception = Exception.new(message)
+        Sentry.capture_exception(exception, opt)
+      end
     end
   end
 end

data/lib/uniform_notifier/slack.rb

@@ -4,9 +4,9 @@ class UniformNotifier
   class Slack < Base
     POSSIBLE_OPTIONS = %i[username channel].freeze
 
-    @slack = nil
-
     class << self
+      @slack = nil
+
       def active?
         @slack
       end

data/lib/uniform_notifier/terminal_notifier.rb

@@ -2,23 +2,25 @@
 
 class UniformNotifier
   class TerminalNotifier < Base
-    def self.active?
-      !!UniformNotifier.terminal_notifier
-    end
+    class << self
+      def active?
+        !!UniformNotifier.terminal_notifier
+      end
 
-    protected
+      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`'
+      def _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
-      end
 
-      ::TerminalNotifier.notify(data[:body], title: data[:title])
+        ::TerminalNotifier.notify(data[:body], title: data[:title])
+      end
     end
   end
 end

data/lib/uniform_notifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UniformNotifier
-  VERSION = '1.14.0'
+  VERSION = '1.14.1'
 end

data/lib/uniform_notifier/xmpp.rb

@@ -2,58 +2,60 @@
 
 class UniformNotifier
   class Xmpp < Base
-    @receiver = nil
-    @xmpp = nil
-    @password = nil
+    class << self
+      @receiver = nil
+      @xmpp = nil
+      @password = nil
 
-    def self.active?
-      @xmpp
-    end
+      def active?
+        @xmpp
+      end
 
-    def self.setup_connection(xmpp_information)
-      return unless xmpp_information
+      def setup_connection(xmpp_information)
+        return unless xmpp_information
 
-      require 'xmpp4r'
+        require 'xmpp4r'
 
-      @xmpp = xmpp_information
-      @receiver = xmpp_information[:receiver]
-      @password = xmpp_information[:password]
-      @account = xmpp_information[:account]
-      @show_online_status = xmpp_information[:show_online_status]
-      @stay_connected = xmpp_information[:stay_connected].nil? ? true : xmpp_information[:stay_connected]
+        @xmpp = xmpp_information
+        @receiver = xmpp_information[:receiver]
+        @password = xmpp_information[:password]
+        @account = xmpp_information[:account]
+        @show_online_status = xmpp_information[:show_online_status]
+        @stay_connected = xmpp_information[:stay_connected].nil? ? true : xmpp_information[:stay_connected]
 
-      connect if @stay_connected
-    rescue LoadError
-      @xmpp = nil
-      raise NotificationError, 'You must install the xmpp4r gem to use XMPP notification: `gem install xmpp4r`'
-    end
+        connect if @stay_connected
+      rescue LoadError
+        @xmpp = nil
+        raise NotificationError, 'You must install the xmpp4r gem to use XMPP notification: `gem install xmpp4r`'
+      end
 
-    protected
+      protected
 
-    def self._out_of_channel_notify(data)
-      message = data.values.compact.join("\n")
+      def _out_of_channel_notify(data)
+        message = data.values.compact.join("\n")
 
-      notify(message)
-    end
+        notify(message)
+      end
 
-    private
+      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 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 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}")
+      def presence_status
+        Jabber::Presence.new.set_status("Uniform Notifier started on #{Time.now}")
+      end
     end
   end
 end

data/spec/uniform_notifier/appsignal_spec.rb

@@ -12,57 +12,64 @@ RSpec.describe UniformNotifier::AppsignalNotifier do
   end
 
   it 'should notify appsignal with keyword title' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), {})
+    expect(Appsignal).to receive(:send_error).with(UniformNotifier::Exception.new('notify appsignal'), {})
 
     UniformNotifier.appsignal = true
     expect(UniformNotifier::AppsignalNotifier.out_of_channel_notify(title: 'notify appsignal'))
   end
 
   it 'should notify appsignal with first argument title' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), {})
+    expect(Appsignal).to receive(:send_error).with(UniformNotifier::Exception.new('notify appsignal'), {})
 
     UniformNotifier.appsignal = true
     UniformNotifier::AppsignalNotifier.out_of_channel_notify('notify appsignal')
   end
 
   it 'should notify appsignal with tags' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), { foo: :bar })
+    expect(Appsignal).to receive(:send_error).with(UniformNotifier::Exception.new('notify appsignal'), { foo: :bar })
 
     UniformNotifier.appsignal = true
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify(title: 'notify appsignal', tags: { foo: :bar})
+    UniformNotifier::AppsignalNotifier.out_of_channel_notify(title: 'notify appsignal', tags: { foo: :bar })
   end
 
   it 'should notify appsignal with default namespace' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), {}, 'web')
+    expect(Appsignal).to receive(:send_error).with(UniformNotifier::Exception.new('notify appsignal'), {}, 'web')
 
     UniformNotifier.appsignal = { namespace: 'web' }
     UniformNotifier::AppsignalNotifier.out_of_channel_notify('notify appsignal')
   end
 
   it 'should notify appsignal with overridden namespace' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), { foo: :bar }, 'background')
+    expect(Appsignal).to receive(:send_error).with(
+      UniformNotifier::Exception.new('notify appsignal'),
+      { foo: :bar },
+      'background'
+    )
 
     UniformNotifier.appsignal = { namespace: 'web' }
     UniformNotifier::AppsignalNotifier.out_of_channel_notify(
       title: 'notify appsignal',
-      tags: { foo: :bar },
+      tags: {
+        foo: :bar
+      },
       namespace: 'background'
     )
   end
 
   it 'should notify appsignal with merged tags' do
-    expect(Appsignal).to receive(:send_error)
-      .with(UniformNotifier::Exception.new('notify appsignal'), { user: 'Bob', hostname: 'frontend2', site: 'first' }, 'background')
+    expect(Appsignal).to receive(:send_error).with(
+      UniformNotifier::Exception.new('notify appsignal'),
+      { user: 'Bob', hostname: 'frontend2', site: 'first' },
+      'background'
+    )
 
     UniformNotifier.appsignal = { namespace: 'web', tags: { hostname: 'frontend1', user: 'Bob' } }
     UniformNotifier::AppsignalNotifier.out_of_channel_notify(
       title: 'notify appsignal',
-      tags: { hostname: 'frontend2', site: 'first' },
+      tags: {
+        hostname: 'frontend2',
+        site: 'first'
+      },
       namespace: 'background'
     )
   end

data/spec/uniform_notifier/bugsnag_spec.rb

@@ -18,7 +18,8 @@ RSpec.describe UniformNotifier::BugsnagNotifier do
     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
+        grouping_hash: notification_data[:body],
+        notification: notification_data
       )
 
       UniformNotifier.bugsnag = true
@@ -28,7 +29,9 @@ RSpec.describe UniformNotifier::BugsnagNotifier do
     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
+        foo: :bar,
+        grouping_hash: notification_data[:body],
+        notification: notification_data
       )
 
       UniformNotifier.bugsnag = { foo: :bar }
@@ -41,7 +44,10 @@ RSpec.describe UniformNotifier::BugsnagNotifier do
     it 'should notify bugsnag' do
       expect(Bugsnag).to receive(:notify).with(
         UniformNotifier::Exception.new('notify bugsnag'),
-        grouping_hash: 'notify bugsnag', notification: { title: 'notify bugsnag' }
+        grouping_hash: 'notify bugsnag',
+        notification: {
+          title: 'notify bugsnag'
+        }
       )
 
       UniformNotifier.bugsnag = true
@@ -51,7 +57,11 @@ RSpec.describe UniformNotifier::BugsnagNotifier do
     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' }
+        foo: :bar,
+        grouping_hash: 'notify bugsnag',
+        notification: {
+          title: 'notify bugsnag'
+        }
       )
 
       UniformNotifier.bugsnag = { foo: :bar }

data/spec/uniform_notifier/growl_spec.rb

@@ -12,12 +12,11 @@ RSpec.describe UniformNotifier::Growl do
     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')
+    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
@@ -29,11 +28,9 @@ RSpec.describe UniformNotifier::Growl do
     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', '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' }
@@ -45,11 +42,9 @@ RSpec.describe UniformNotifier::Growl do
     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', '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' }

data/spec/uniform_notifier/javascript_alert_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe UniformNotifier::JavascriptAlert do
   end
 
   it 'should accept custom attributes' do
-    UniformNotifier.alert = { attributes: { nonce: 'my-nonce', 'data-key' => :value } }
+    UniformNotifier.alert = { attributes: { :nonce => 'my-nonce', 'data-key' => :value } }
     expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
       <script type="text/javascript" nonce="my-nonce" data-key="value">/*<![CDATA[*/
       alert( "javascript alert!" );

data/spec/uniform_notifier/javascript_console_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe UniformNotifier::JavascriptConsole do
   end
 
   it 'should accept custom attributes' do
-    UniformNotifier.console = { attributes: { nonce: 'my-nonce', 'data-key' => :value } }
+    UniformNotifier.console = { attributes: { :nonce => 'my-nonce', 'data-key' => :value } }
     expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to eq <<~CODE
       <script type="text/javascript" nonce="my-nonce" data-key="value">/*<![CDATA[*/
       if (typeof(console) !== 'undefined' && console.log) {

data/spec/uniform_notifier/sentry_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-class Raven
+class Sentry
   # mock Sentry
 end
 
@@ -12,14 +12,14 @@ RSpec.describe UniformNotifier::SentryNotifier do
   end
 
   it 'should notify sentry' do
-    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), {})
+    expect(Sentry).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), {})
 
     UniformNotifier.sentry = true
     UniformNotifier::SentryNotifier.out_of_channel_notify(title: 'notify sentry')
   end
 
   it 'should notify sentry' do
-    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), foo: :bar)
+    expect(Sentry).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), foo: :bar)
 
     UniformNotifier.sentry = { foo: :bar }
     UniformNotifier::SentryNotifier.out_of_channel_notify('notify sentry')

data/spec/uniform_notifier/slack_spec.rb

@@ -20,7 +20,6 @@ RSpec.describe UniformNotifier::Slack do
         begin
           UniformNotifier.slack = {}
         rescue UniformNotifier::NotificationError
-
         ensure
           expect_any_instance_of(Slack::Notifier).to_not receive(:ping)
           expect(UniformNotifier::Slack.out_of_channel_notify(title: 'notify slack')).to be_nil
@@ -35,7 +34,8 @@ RSpec.describe UniformNotifier::Slack do
     end
 
     it 'should allow username and channel config options' do
-      expect(Slack::Notifier).to receive(:new).with('http://some.slack.url', username: 'The Dude', channel: '#carpets')
+      expect(Slack::Notifier).to receive(:new)
+        .with('http://some.slack.url', username: 'The Dude', channel: '#carpets')
         .and_return(true)
       UniformNotifier.slack = { webhook_url: 'http://some.slack.url', username: 'The Dude', channel: '#carpets' }
       expect(UniformNotifier::Slack.active?).to eq true

data/spec/uniform_notifier/xmpp_spec.rb

@@ -22,7 +22,10 @@ RSpec.describe UniformNotifier::Xmpp do
     expect(xmpp).to receive(:send).with(message)
 
     UniformNotifier.xmpp = {
-      account: 'from@gmail.com', password: '123456', receiver: 'to@gmail.com', show_online_status: false
+      account: 'from@gmail.com',
+      password: '123456',
+      receiver: 'to@gmail.com',
+      show_online_status: false
     }
     UniformNotifier::Xmpp.out_of_channel_notify(title: 'notify xmpp')
   end
@@ -49,7 +52,10 @@ RSpec.describe UniformNotifier::Xmpp do
     expect(xmpp).to receive(:send).with(message)
 
     UniformNotifier.xmpp = {
-      account: 'from@gmail.com', password: '123456', receiver: 'to@gmail.com', show_online_status: true
+      account: 'from@gmail.com',
+      password: '123456',
+      receiver: 'to@gmail.com',
+      show_online_status: true
     }
     UniformNotifier::Xmpp.out_of_channel_notify(title: 'notify xmpp')
   end

data/uniform_notifier.gemspec

@@ -17,8 +17,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.3'
 
   s.add_development_dependency 'rspec', ['> 0']
-  s.add_development_dependency 'ruby-growl', ['= 4.0']
   s.add_development_dependency 'ruby_gntp', ['= 0.3.4']
+  s.add_development_dependency 'ruby-growl', ['= 4.0']
   s.add_development_dependency 'slack-notifier', ['>= 1.0']
   s.add_development_dependency 'xmpp4r', ['= 0.5']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uniform_notifier
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 1.14.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-26 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-growl
+  name: ruby_gntp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 0.3.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
-  name: ruby_gntp
+  name: ruby-growl
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: slack-notifier
   requirement: !ruby/object:Gem::Requirement