uniform_notifier 1.18.0 → 1.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13425e561720688fc38379efb2984fd1d78074ffc4cf0d3b63ed3871c6af3a33
-  data.tar.gz: 0c32e472aff6ecdd79637de33eab3c11b2610a30722b818faf4261015a5123bc
+  metadata.gz: 0b1bd2e74026fffc6dabe2ecf5b5709884283e3cb7cf1c48d59f0df21a19b042
+  data.tar.gz: '093fef4d90199788c807a044e238aadbb51410857ac17a91c653292a854e1ff9'
 SHA512:
-  metadata.gz: bcb11a6a339a01a05d99d443352f9fc8271718b8e2941e082bfafdb23f97b570ff5e9bcecc14e6464e6740c5ccd5b457880ddd26d144ac322c812949eef647d1
-  data.tar.gz: 5b020147e831c1c3423de9d06353e577cb6bdb3dc7a063059ff82d4e2ccd30058ef5440fab6a8637a303a400e22e4fb7c95bd57a904dd315155e7c0e94155cd5
+  metadata.gz: 1563e705f564ee432a7a0e6ffc357409c66f064496beac12c2a25b375dce008bade16584f4fa924b3447f69a0f3460005c8141c3980279c553ac0726b6443dfb
+  data.tar.gz: d494338a31ef48bad2bee9bb60dde9c1bab2ff05c0fbc45301076fcd8a73a5240c530241f01c60dfdcc926baac3f13f25b09f2a19a916dd1b0662bcc3786079a

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Next Release
 
+## 1.18.1 (10/13/2026)
+
+* Reduce gem size by excluding unnecessary file
+
 ## 1.18.0 (08/31/2025)
 
 * Update `Honeybadger.notify` signature to match new keyword style

data/lib/uniform_notifier/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uniform_notifier
 version: !ruby/object:Gem::Version
-  version: 1.18.0
+  version: 1.18.1
 platform: ruby
 authors:
 - Richard Huang
@@ -51,21 +51,18 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '0.5'
-description: uniform notifier for rails logger, customized logger, javascript alert,
-  javascript console and xmpp
+description: uniform_notifier gives you the ability to send notification through rails
+  logger, customized logger, javascript alert, javascript console, xmpp, airbrake,
+  honeybadger, AppSignal and more
 email:
 - flyerhzm@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/ci.yml"
-- ".gitignore"
 - CHANGELOG.md
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - lib/uniform_notifier.rb
 - lib/uniform_notifier/airbrake.rb
 - lib/uniform_notifier/appsignal.rb
@@ -85,24 +82,6 @@ files:
 - lib/uniform_notifier/terminal_notifier.rb
 - lib/uniform_notifier/version.rb
 - lib/uniform_notifier/xmpp.rb
-- spec/spec_helper.rb
-- spec/uniform_notifier/airbrake_spec.rb
-- spec/uniform_notifier/appsignal_spec.rb
-- spec/uniform_notifier/base_spec.rb
-- spec/uniform_notifier/bugsnag_spec.rb
-- spec/uniform_notifier/customized_logger_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/opentelemetry_spec.rb
-- spec/uniform_notifier/rails_logger_spec.rb
-- spec/uniform_notifier/raise_spec.rb
-- spec/uniform_notifier/rollbar_spec.rb
-- spec/uniform_notifier/sentry_spec.rb
-- spec/uniform_notifier/slack_spec.rb
-- spec/uniform_notifier/terminal_notifier_spec.rb
-- spec/uniform_notifier/xmpp_spec.rb
-- uniform_notifier.gemspec
 homepage: http://rubygems.org/gems/uniform_notifier
 licenses:
 - MIT
@@ -124,25 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: uniform notifier for rails logger, customized logger, javascript alert, javascript
   console and xmpp
-test_files:
-- spec/spec_helper.rb
-- spec/uniform_notifier/airbrake_spec.rb
-- spec/uniform_notifier/appsignal_spec.rb
-- spec/uniform_notifier/base_spec.rb
-- spec/uniform_notifier/bugsnag_spec.rb
-- spec/uniform_notifier/customized_logger_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/opentelemetry_spec.rb
-- spec/uniform_notifier/rails_logger_spec.rb
-- spec/uniform_notifier/raise_spec.rb
-- spec/uniform_notifier/rollbar_spec.rb
-- spec/uniform_notifier/sentry_spec.rb
-- spec/uniform_notifier/slack_spec.rb
-- spec/uniform_notifier/terminal_notifier_spec.rb
-- spec/uniform_notifier/xmpp_spec.rb
+test_files: []

data/.github/workflows/ci.yml

@@ -1,27 +0,0 @@
-name: CI
-
-on:
-  - push
-  - pull_request
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby:
-          - 3.0
-          - 3.1
-          - 3.2
-          - 3.3
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - name: Run tests
-        run: bundle exec rake

data/.gitignore

@@ -1,6 +0,0 @@
-pkg/*
-*.gem
-.bundle
-.rvmrc
-bin/
-Gemfile.lock

data/Gemfile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in uniform_notifier.gemspec
-gemspec
-
-gem 'rake'
-gem 'rexml' # for Ruby 3.0+

data/Rakefile

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rake'
-require 'rdoc/task'
-require 'rspec'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-RSpec::Core::RakeTask.new('spec:progress') do |spec|
-  spec.rspec_opts = %w[--format progress]
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "uniform_notifier #{UniformNotifier::VERSION}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-task default: :spec

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'uniform_notifier'
-require 'xmpp4r'
-require 'slack-notifier'
-require 'rspec'

data/spec/uniform_notifier/airbrake_spec.rb

@@ -1,27 +0,0 @@
-# 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
-  end
-
-  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')
-  end
-
-  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')
-  end
-end

data/spec/uniform_notifier/appsignal_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class Appsignal
-  # mock AppSignal
-end
-
-RSpec.describe UniformNotifier::AppsignalNotifier do
-  it 'should not notify appsignal' do
-    expect(UniformNotifier::AppsignalNotifier.out_of_channel_notify(title: 'notify appsignal')).to be_nil
-  end
-
-  it 'should notify appsignal with keyword title' do
-    expect(Appsignal).to receive(:send_error).with(UniformNotifier::Exception.new("notify appsignal\n"))
-
-    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\n")
-    )
-
-    UniformNotifier.appsignal = true
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify('notify appsignal')
-  end
-
-  it 'should notify appsignal with tags' do
-    transaction = double('Appsignal::Transaction', set_namespace: nil)
-    expect(transaction).to receive(:set_tags).with({ foo: :bar })
-    expect(Appsignal).to receive(:send_error).with(
-      UniformNotifier::Exception.new("notify appsignal\n")
-    ).and_yield(transaction)
-
-    UniformNotifier.appsignal = true
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify(title: 'notify appsignal', tags: { foo: :bar })
-  end
-
-  it 'should notify appsignal with default namespace' do
-    transaction = double('Appsignal::Transaction', set_tags: nil)
-    expect(transaction).to receive(:set_namespace).with('web')
-    expect(Appsignal).to receive(:send_error).with(
-      UniformNotifier::Exception.new("notify appsignal\n")
-    ).and_yield(transaction)
-
-    UniformNotifier.appsignal = { namespace: 'web' }
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify('notify appsignal')
-  end
-
-  it 'should notify appsignal with overridden namespace' do
-    transaction = double('Appsignal::Transaction')
-    expect(transaction).to receive(:set_tags).with({ foo: :bar })
-    expect(transaction).to receive(:set_namespace).with('background')
-    expect(Appsignal).to receive(:send_error).with(
-      UniformNotifier::Exception.new("notify appsignal\nbody")
-    ).and_yield(transaction)
-
-    UniformNotifier.appsignal = { namespace: 'web' }
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify(
-      title: 'notify appsignal',
-      tags: {
-        foo: :bar
-      },
-      namespace: 'background',
-      body: 'body',
-    )
-  end
-
-  it 'should notify appsignal with merged tags' do
-    transaction = double('Appsignal::Transaction')
-    expect(transaction).to receive(:set_tags).with({ user: 'Bob', hostname: 'frontend2', site: 'first' })
-    expect(transaction).to receive(:set_namespace).with('background')
-    expect(Appsignal).to receive(:send_error).with(
-      UniformNotifier::Exception.new("notify appsignal\nbody")
-    ).and_yield(transaction)
-
-    UniformNotifier.appsignal = { namespace: 'web', tags: { hostname: 'frontend1', user: 'Bob' } }
-    UniformNotifier::AppsignalNotifier.out_of_channel_notify(
-      title: 'notify appsignal',
-      tags: {
-        hostname: 'frontend2',
-        site: 'first'
-      },
-      body: 'body',
-      namespace: 'background'
-    )
-  end
-end

data/spec/uniform_notifier/base_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::Base do
-  context '#inline_channel_notify' do
-    before { allow(UniformNotifier::Base).to receive(:active?).and_return(true) }
-    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
-    before { allow(UniformNotifier::Base).to receive(:active?).and_return(true) }
-    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,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class Bugsnag
-  # mock Bugsnag
-end
-
-RSpec.describe UniformNotifier::BugsnagNotifier do
-  let(:notification_data) { {} }
-  let(:report) { double('Bugsnag::Report') }
-  before do
-    allow(report).to receive(:severity=)
-    allow(report).to receive(:add_tab)
-    allow(report).to receive(:grouping_hash=)
-  end
-  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) { 'notify bugsnag' }
-
-    it 'should notify bugsnag' do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data)).and_yield(report)
-      expect(report).to receive(:severity=).with('warning')
-      expect(report).to receive(:add_tab).with(:bullet, { title: notification_data })
-      expect(report).to receive(:grouping_hash=).with(notification_data)
-
-      UniformNotifier.bugsnag = true
-      UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
-    end
-
-    it 'should notify bugsnag with additional report configuration' do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data)).and_yield(report)
-      expect(report).to receive(:meta_data=).with({ foo: :bar })
-
-      UniformNotifier.bugsnag = ->(report) { report.meta_data = { foo: :bar } }
-      UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
-    end
-  end
-  context 'with hash 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])
-      ).and_yield(report)
-      expect(report).to receive(:severity=).with('warning')
-      expect(report).to receive(:add_tab).with(:bullet, notification_data)
-      expect(report).to receive(:grouping_hash=).with(notification_data[:body])
-
-      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])
-      ).and_yield(report)
-      expect(report).to receive(:meta_data=).with({ foo: :bar })
-
-      UniformNotifier.bugsnag = ->(report) { report.meta_data = { foo: :bar } }
-      UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
-    end
-  end
-
-  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']
-    end
-    UniformNotifier.bugsnag = true
-    UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ['bugsnag spec test'])
-  end
-end

data/spec/uniform_notifier/customized_logger_spec.rb

@@ -1,24 +0,0 @@
-# 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
-  end
-
-  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')
-
-    logger.seek(0)
-    expect(logger.read).to eq "#{now.strftime('%Y-%m-%d %H:%M:%S')}[WARN] notify rails logger"
-
-    File.delete('test.log')
-  end
-end

data/spec/uniform_notifier/honeybadger_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-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,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::JavascriptAlert do
-  it 'should not notify message' do
-    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to be_nil
-  end
-
-  it 'should notify message' do
-    UniformNotifier.alert = true
-    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
-      <script type="text/javascript">/*<![CDATA[*/
-      alert( "javascript alert!" );
-      /*]]>*/</script>
-    CODE
-  end
-
-  it 'should accept custom attributes' do
-    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!" );
-      /*]]>*/</script>
-    CODE
-  end
-
-  it 'should have default attributes if no attributes settings exist' do
-    UniformNotifier.alert = {}
-    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
-      <script type="text/javascript">/*<![CDATA[*/
-      alert( "javascript alert!" );
-      /*]]>*/</script>
-    CODE
-  end
-end

data/spec/uniform_notifier/javascript_console_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::JavascriptConsole do
-  it 'should not notify message' do
-    expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to be_nil
-  end
-
-  it 'should notify message' do
-    UniformNotifier.console = true
-    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) {
-          console.groupCollapsed(#{'Uniform Notifier'.inspect});
-          console.log(#{'javascript console!'.inspect});
-          console.groupEnd();
-        } else {
-          console.log(#{'javascript console!'.inspect});
-        }
-      }
-
-      /*]]>*/</script>
-    CODE
-  end
-
-  it 'should accept custom attributes' do
-    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) {
-        if (console.groupCollapsed && console.groupEnd) {
-          console.groupCollapsed(#{'Uniform Notifier'.inspect});
-          console.log(#{'javascript console!'.inspect});
-          console.groupEnd();
-        } else {
-          console.log(#{'javascript console!'.inspect});
-        }
-      }
-
-      /*]]>*/</script>
-    CODE
-  end
-
-  it 'should have default attributes if no attributes settings exist' do
-    UniformNotifier.console = {}
-    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) {
-          console.groupCollapsed(#{'Uniform Notifier'.inspect});
-          console.log(#{'javascript console!'.inspect});
-          console.groupEnd();
-        } else {
-          console.log(#{'javascript console!'.inspect});
-        }
-      }
-
-      /*]]>*/</script>
-    CODE
-  end
-end

data/spec/uniform_notifier/opentelemetry_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class OpenTelemetry
-  class Trace
-    # mock OpenTelemetry
-  end
-end
-
-RSpec.describe UniformNotifier::OpenTelemetryNotifier do
-  it 'should not notify OpenTelemetry' do
-    expect(UniformNotifier::OpenTelemetryNotifier.out_of_channel_notify(title: 'notify otel')).to be_nil
-  end
-
-  it 'should notify OpenTelemetry' do
-    span = double('span')
-    expect(span).to receive(:record_exception).with(UniformNotifier::Exception.new('notify otel'))
-    expect(OpenTelemetry::Trace).to receive(:current_span).and_return(span)
-
-    UniformNotifier.opentelemetry = true
-    UniformNotifier::OpenTelemetryNotifier.out_of_channel_notify(title: 'notify otel')
-  end
-
-  it 'should notify OpenTelemetry' do
-    span = double('span')
-    expect(span).to receive(:record_exception).with(UniformNotifier::Exception.new('notify otel'))
-    expect(OpenTelemetry::Trace).to receive(:current_span).and_return(span)
-
-    UniformNotifier.opentelemetry = { foo: :bar }
-    UniformNotifier::OpenTelemetryNotifier.out_of_channel_notify('notify otel')
-  end
-end

data/spec/uniform_notifier/rails_logger_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class Rails
-  # mock Rails
-end
-
-RSpec.describe UniformNotifier::RailsLogger do
-  it 'should not notify rails logger' do
-    expect(UniformNotifier::RailsLogger.out_of_channel_notify(title: 'notify rails logger')).to be_nil
-  end
-
-  it 'should notify rails logger' do
-    logger = double('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')
-  end
-end

data/spec/uniform_notifier/raise_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::Raise do
-  it 'should not notify message' do
-    expect(UniformNotifier::Raise.out_of_channel_notify(title: 'notification')).to be_nil
-  end
-
-  it 'should raise error of the default class' do
-    UniformNotifier.raise = true
-    expect { UniformNotifier::Raise.out_of_channel_notify(title: 'notification') }
-      .to raise_error(
-        UniformNotifier::Exception,
-        'notification'
-      )
-  end
-
-  it 'allows the user to override the default exception class' do
-    klass = Class.new(RuntimeError)
-    UniformNotifier.raise = klass
-    expect { UniformNotifier::Raise.out_of_channel_notify(title: 'notification') }
-      .to raise_error(klass, 'notification')
-  end
-
-  it 'can be turned from on to off again' do
-    UniformNotifier.raise = true
-    UniformNotifier.raise = false
-
-    expect { UniformNotifier::Raise.out_of_channel_notify(title: 'notification') }
-      .not_to raise_error
-  end
-end

data/spec/uniform_notifier/rollbar_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class Rollbar
-  # mock Rollbar
-end
-
-RSpec.describe UniformNotifier::RollbarNotifier do
-  it 'should not notify rollbar' do
-    expect(UniformNotifier::RollbarNotifier.out_of_channel_notify(title: 'notify rollbar')).to be_nil
-  end
-
-  it 'should notify rollbar' do
-    expect(Rollbar).to receive(:log).with('info', UniformNotifier::Exception.new('notify rollbar'))
-
-    UniformNotifier.rollbar = true
-    UniformNotifier::RollbarNotifier.out_of_channel_notify(title: 'notify rollbar')
-  end
-
-  it 'should notify rollbar' do
-    expect(Rollbar).to receive(:log).with('warning', UniformNotifier::Exception.new('notify rollbar'))
-
-    UniformNotifier.rollbar = { level: 'warning' }
-    UniformNotifier::RollbarNotifier.out_of_channel_notify(title: 'notify rollbar')
-  end
-end

data/spec/uniform_notifier/sentry_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class Sentry
-  # mock Sentry
-end
-
-RSpec.describe UniformNotifier::SentryNotifier do
-  it 'should not notify sentry' do
-    expect(UniformNotifier::SentryNotifier.out_of_channel_notify(title: 'notify sentry')).to be_nil
-  end
-
-  it 'should notify sentry' do
-    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(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')
-  end
-end

data/spec/uniform_notifier/slack_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-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)
-      expect(UniformNotifier::Slack.out_of_channel_notify(title: 'notify slack')).to be_nil
-    end
-  end
-
-  context 'configuration' do
-    context 'no webhook_url is given' do
-      it 'should raise an error' do
-        expect { UniformNotifier.slack = {} }
-          .to raise_error(UniformNotifier::NotificationError)
-      end
-
-      it 'should not notify 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
-        end
-      end
-    end
-
-    it 'should remove invalid options' do
-      expect(Slack::Notifier).to receive(:new).with('http://some.slack.url', {}).and_return(true)
-      UniformNotifier.slack = { webhook_url: 'http://some.slack.url', pizza: 'pepperoni' }
-      expect(UniformNotifier::Slack.active?).to eq true
-    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' })
-        .and_return(true)
-      UniformNotifier.slack = { webhook_url: 'http://some.slack.url', username: 'The Dude', channel: '#carpets' }
-      expect(UniformNotifier::Slack.active?).to eq true
-    end
-  end
-
-  context 'properly configured' do
-    before(:example) do
-      @message = 'notify slack'
-      allow_any_instance_of(Slack::Notifier).to receive(:ping).and_return(@message)
-    end
-
-    it 'should notify slack' do
-      UniformNotifier.slack = { webhook_url: 'http://some.slack.url' }
-      expect_any_instance_of(Slack::Notifier).to receive(:ping)
-      expect(UniformNotifier::Slack.out_of_channel_notify(title: @message)).to eq @message
-    end
-  end
-end

data/spec/uniform_notifier/terminal_notifier_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::TerminalNotifier do
-  it 'should not notify terminal-notifier when disabled' do
-    expect(UniformNotifier::TerminalNotifier.out_of_channel_notify(title: 'notify terminal')).to be_nil
-  end
-
-  it "should raise an exception when terminal-notifier gem isn't available" do
-    UniformNotifier.terminal_notifier = true
-    expect {
-      UniformNotifier::TerminalNotifier.out_of_channel_notify(body: 'body', title: 'notify terminal')
-    }.to raise_error(UniformNotifier::NotificationError, /terminal-notifier gem/)
-  end
-
-  it 'should notify terminal-notifier when enabled' do
-    module TerminalNotifier
-      # mock TerminalNotifier
-    end
-
-    expect(TerminalNotifier).to receive(:notify).with('body', title: 'notify terminal')
-
-    UniformNotifier.terminal_notifier = true
-    UniformNotifier::TerminalNotifier.out_of_channel_notify(body: 'body', title: 'notify terminal')
-  end
-end

data/spec/uniform_notifier/xmpp_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe UniformNotifier::Xmpp do
-  it 'should not notify xmpp' do
-    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')
-    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')
-    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')
-  end
-
-  it 'should notify xmpp with online status' do
-    jid = double('jid')
-    xmpp = double('xmpp')
-    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
-    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')
-    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')
-  end
-end

data/uniform_notifier.gemspec

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-require 'uniform_notifier/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'uniform_notifier'
-  s.version     = UniformNotifier::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Richard Huang']
-  s.email       = ['flyerhzm@gmail.com']
-  s.homepage    = 'http://rubygems.org/gems/uniform_notifier'
-  s.summary     = 'uniform notifier for rails logger, customized logger, javascript alert, javascript console and xmpp'
-  s.description = 'uniform notifier for rails logger, customized logger, javascript alert, javascript console and xmpp'
-  s.license     = 'MIT'
-
-  s.required_ruby_version = '>= 2.3'
-
-  s.add_development_dependency 'rspec', ['> 0']
-  s.add_development_dependency 'slack-notifier', ['>= 1.0']
-  s.add_development_dependency 'xmpp4r', ['= 0.5']
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = ['lib']
-
-  if s.respond_to?(:metadata)
-    s.metadata['changelog_uri'] = 'https://github.com/flyerhzm/uniform_notifier/blob/master/CHANGELOG.md'
-    s.metadata['source_code_uri'] = 'https://github.com/flyerhzm/uniform_notifier'
-    s.metadata['bug_tracker_uri'] = 'https://github.com/flyerhzm/uniform_notifier/issues'
-  end
-end