active_delivery 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '035688fbd824e8e5d02dd88db1e6efca8bdb208383143692b4fd12e1b0d39590'
-  data.tar.gz: 7be86b0fb03ec57dfcd6c60ec32354d4ba11980b8a960117489ca4be133d2181
+  metadata.gz: 49196fc041ea378e47c1a43a527d555b9822398570553d094b5d4ac051fe215b
+  data.tar.gz: ad331e02883c5e9bd8c7b07f9acdd531d7aa64cbec0a589dc24ac5ed2f30ad74
 SHA512:
-  metadata.gz: 41d29416af71eac7bb70d22c2f4118dfa47ca15d4ba80a6059c1b4c8769c7c07be791b38fc0235aceec1da28f6456bd4c5150fb0bdaa9f3c4d8e4775ce20f836
-  data.tar.gz: ac251a726f3aafec70461dff4c52646bc3d25c388ec8146d8484957d37f454950e94b756295d8e9f1f59342aa48ade25674287cbb368cf04a1eaf28a3cb6b5ba
+  metadata.gz: 2c9f5f9cd717c0bba343c2f2ec2f82390c680a6c5df1561e70ef4e6e913f6dd7204456f0238e0a2c60df25274bf09bd55b2081a5441e793ff9e39c22f40b2fc5
+  data.tar.gz: 0c423ef6827bb61f279f18094a9f4e57033086bc8aaac067e8a0c11a71f81e8005d7084b15d263f3d25908bccabdcee302dcec8f427927bc8c3bb27169788a72

data/.gitignore

@@ -6,3 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock
+Gemfile.local

data/.rspec

@@ -1,3 +1,2 @@
 --format documentation
 --color
---require spec_helper

data/.rubocop.yml

@@ -1,2 +1,26 @@
+require:
+  - standard/cop/semantic_blocks
+
 inherit_gem:
-  common-rubocop: config/base.yml
+  standard: config/base.yml
+
+AllCops:
+  Exclude:
+    - 'bin/*'
+    - 'tmp/**/*'
+    - 'Gemfile'
+    - 'node_modules/**/*'
+    - 'vendor/**/*'
+  DisplayCopNames: true
+
+Standard/SemanticBlocks:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: no_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: no_comma
+
+Layout/AlignParameters:
+  EnforcedStyle: with_first_parameter

data/.travis.yml

@@ -0,0 +1,26 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+
+notifications:
+  email: false
+
+matrix:
+  fast_finish: true
+  include:
+    - rvm: ruby-head
+      gemfile: gemfiles/railsmaster.gemfile
+    - rvm: 2.5.1
+      gemfile: Gemfile
+    - rvm: 2.5.1
+      gemfile: Gemfile
+      env:
+        - NO_RAILS=1
+    - rvm: 2.4.3
+      gemfile: Gemfile
+    - rvm: 2.3.1
+      gemfile: gemfiles/rails42.gemfile
+  allow_failures:
+    - rvm: ruby-head
+      gemfile: gemfiles/railsmaster.gemfile

data/Gemfile

@@ -2,4 +2,12 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "common-rubocop", path: "../common-rubocop"
+gem "pry-byebug"
+
+local_gemfile = File.join(__dir__, "Gemfile.local")
+
+if File.exist?(local_gemfile)
+  eval(File.read(local_gemfile)) # rubocop:disable Security/Eval
+else
+  gem "rails", "~> 5.2"
+end

data/README.md

@@ -1,7 +1,49 @@
+[![Gem Version](https://badge.fury.io/rb/active_delivery.svg)](https://badge.fury.io/rb/active_delivery)
+[![Build Status](https://travis-ci.org/palkan/active_delivery.svg?branch=master)](https://travis-ci.org/palkan/active_delivery)
+
 # Active Delivery
 
 Framework providing an entrypoint (single _interface_) for all types of notifications: mailers, push notifications, whatever you want.
 
+<a href="https://evilmartians.com/?utm_source=action_policy">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+Requirements:
+- Ruby ~> 2.3
+
+**NOTE**: although most of the examples in this readme are Rails-specific, this gem could be used without Rails/ActiveSupport.
+
+## The problem
+
+We need a way to handle different notifications _channel_ (mail, push) in one place.
+
+From the business-logic point of view we want to _notify_ a user, hence we need a _separate abstraction layer_ as an entrypoint to different types of notifications.
+
+## The solution
+
+Here comes the _Active Delivery_.
+
+In the simplest case when we have only mailers Active Delivery is just a wrapper for Mailer with (possibly) some additional logic provided (e.g. preventing emails to unsubscribed users).
+
+Motivations behind Active Delivery:
+- organize notifications related logic:
+
+```ruby
+# Before
+def after_some_action
+  MyMailer.with(user: user).some_action.deliver_later if user.receive_emails?
+  NotifyService.send_notification(user, "action") if whatever_else?
+end
+
+# After
+def after_some_action
+  MyDelivery.with(user: user).notify(:some_action)
+end
+```
+
+- better testability (see [Testing](#testing)).
+
+
 ## Usage
 
 _Delivery_ class is used to trigger notifications. It describes how to notify a user (e.g. via email or via push notification or both):
@@ -43,6 +85,59 @@ PostsMailer.with(user: user).published(post)
 
 See [Rails docs](https://api.rubyonrails.org/classes/ActionMailer/Parameterized.html) for more information on parameterized mailers.
 
+## Callbacks support
+
+**NOTE:** callbacks are only available if ActiveSupport is present in the app's env.
+
+```ruby
+# Run method before delivering notification
+# NOTE: when `false` is returned the executation is halted
+before_notify :do_something
+
+# You can specify a notification method (to run callback only for that method)
+before_notify :do_mail_something, on: :mailer
+
+# after_ and around_ callbacks are also supported
+after_notify :cleanup
+
+around_notify :set_context
+```
+
+## Testing
+
+**NOTE:** RSpec only for the time being.
+
+Active Delivery provides an elegant way to test deliveries in your code (i.e. when you want to test whether a notification has been sent) through a `have_delivered_to` matcher:
+
+```ruby
+it "delivers notification" do
+  expect { subject }.to have_delivered_to(Community::EventsDelivery, :modified, event)
+    .with(profile: profile)
+```
+
+You can also use such RSpec features as [compound expectations](https://relishapp.com/rspec/rspec-expectations/docs/compound-expectations) and [composed matchers](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/composing-matchers):
+
+```ruby
+it "delivers to rsvped members via .notify" do
+  expect { subject }.
+    to have_delivered_to(Community::EventsDelivery, :canceled, an_instance_of(event)).with(
+      a_hash_including(profile: another_profile)
+    ).and have_delivered_to(Community::EventsDelivery, :canceled, event).with(
+      profile: profile
+    )
+end
+```
+
+If you want to test that no notification is deliver you can use negation:
+
+```ruby
+specify "when event is not found" do
+  expect do
+    described_class.perform_now(profile.id, "123", "one_hour_before")
+  end.not_to have_delivered_to(Community::EventsDelivery)
+end
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/active_delivery.

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
+RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: [:rubocop, :spec]

data/active_delivery.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -14,17 +15,11 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/palkan/active_delivery"
   spec.license       = "MIT"
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "standard", "~> 0.0.12"
 end

data/gemfiles/rails42.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.2"
+gem "actionmailer", "~> 4.2"
+
+gemspec path: ".."

data/gemfiles/railsmaster.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "rails", github: "rails/rails"
+gem "rubocop", github: "rubocop-hq/rubocop"
+
+gemspec path: ".."

data/lib/active_delivery/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  # Base class for deliveries.
+  #
+  # Delivery object describes how to notify a user about
+  # an event (e.g. via email or via push notification or both).
+  #
+  # Delivery class acts like a proxy in front of the different delivery channels
+  # (i.e. mailers, notifiers). That means that calling a method on delivery class invokes the
+  # same method on the corresponding class, e.g.:
+  #
+  #   EventsDelivery.notify(:one_hour_before, profile, event)
+  #
+  #   # under the hood it calls
+  #   EventsMailer.one_hour_before(profile, event).deliver_later
+  #
+  #   # and
+  #   EventsNotifier.one_hour_before(profile, event).notify_later
+  #
+  # Delivery also supports _parameterized_ calling:
+  #
+  #   EventsDelivery.with(profile: profile).notify(:canceled, event)
+  #
+  # The parameters could be accessed through `params` instance method (e.g.
+  # to implement guard-like logic).
+  #
+  # When params are presents the parametrized mailer is used, i.e.:
+  #
+  #   EventsMailer.with(profile: profile).canceled(event)
+  #
+  # See https://api.rubyonrails.org/classes/ActionMailer/Parameterized.html
+  class Base
+    class << self
+      alias with new
+
+      # Enqueues delivery (i.e. uses #deliver_later for mailers)
+      def notify(*args)
+        new.notify(*args)
+      end
+
+      # The same as .notify but delivers synchronously
+      # (i.e. #deliver_now for mailers)
+      def notify!(mid, *args, **hargs)
+        notify(mid, *args, **hargs, sync: true)
+      end
+
+      def delivery_lines
+        @lines ||= begin
+          if superclass.respond_to?(:delivery_lines)
+            superclass.delivery_lines.each_with_object({}) do |(key, val), acc|
+              acc[key] = val.dup_for(self)
+            end
+          else
+            {}
+          end
+        end
+      end
+
+      def register_line(line_id, line_class, **options)
+        delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **options)
+
+        instance_eval <<~CODE, __FILE__, __LINE__ + 1
+          def #{line_id}(val)
+            delivery_lines[:#{line_id}].handler_class = val
+          end
+
+          def #{line_id}_class
+            delivery_lines[:#{line_id}].handler_class
+          end
+        CODE
+      end
+    end
+
+    attr_reader :params
+
+    def initialize(**params)
+      @params = params
+      @params.freeze
+    end
+
+    # Enqueues delivery (i.e. uses #deliver_later for mailers)
+    def notify(mid, *args, sync: false)
+      delivery_lines.each do |type, line|
+        next if line.handler_class.nil?
+        next unless line.notify?(mid)
+
+        notify_line(type, mid, *args, params: params, sync: sync)
+      end
+    end
+
+    # The same as .notify but delivers synchronously
+    # (i.e. #deliver_now for mailers)
+    def notify!(mid, *args, **hargs)
+      notify(mid, *args, **hargs, sync: true)
+    end
+
+    private
+
+    def notify_line(type, mid, *args)
+      delivery_lines[type].notify(mid, *args)
+    end
+
+    def delivery_lines
+      self.class.delivery_lines
+    end
+  end
+end

data/lib/active_delivery/callbacks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/version"
+require "active_support/callbacks"
+require "active_support/concern"
+
+module ActiveDelivery
+  # Add callbacks support to Active Delivery (requires ActiveSupport::Callbacks)
+  #
+  #   # Run method before delivering notification
+  #   # NOTE: when `false` is returned the executation is halted
+  #   before_notify :do_something
+  #
+  #   # You can specify a notification method (to run callback only for that method)
+  #   before_notify :do_mail_something, on: :mail
+  #
+  #   # or for push notifications
+  #   before_notify :do_mail_something, on: :push
+  #
+  #   # after_ and around_ callbacks are also supported
+  #   after_notify :cleanup
+  #
+  #   around_notify :set_context
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Callbacks
+
+    CALLBACK_TERMINATOR = if ::ActiveSupport::VERSION::MAJOR >= 5
+      ->(_target, result) { result.call == false }
+    else
+      ->(_target, result) { result == false }
+    end
+
+    included do
+      # Define "global" callbacks
+      define_line_callbacks :notify
+
+      prepend InstanceExt
+      singleton_class.prepend SingltonExt
+    end
+
+    module InstanceExt
+      def notify(*)
+        run_callbacks(:notify) { super }
+      end
+
+      def notify_line(type, *)
+        run_callbacks(type) { super }
+      end
+    end
+
+    module SingltonExt
+      def register_line(line_id, *args)
+        super
+        define_line_callbacks line_id
+      end
+    end
+
+    class_methods do
+      def define_line_callbacks(name)
+        define_callbacks name,
+                         terminator: CALLBACK_TERMINATOR,
+                         skip_after_callbacks_if_terminated: true
+      end
+
+      def before_notify(method_name, on: :notify)
+        set_callback on, :before, method_name
+      end
+
+      def after_notify(method_name, on: :notify)
+        set_callback on, :after, method_name
+      end
+
+      def around_notify(method_name, on: :notify)
+        set_callback on, :around, method_name
+      end
+    end
+  end
+end
+
+ActiveDelivery::Base.include ActiveDelivery::Callbacks

data/lib/active_delivery/lines/base.rb

@@ -0,0 +1,55 @@
+module ActiveDelivery
+  module Lines
+    class Base
+      attr_reader :id, :options
+      attr_accessor :owner
+      attr_writer :handler_class
+
+      def initialize(id:, owner:, **options)
+        @id = id
+        @owner = owner
+        @options = options.tap(&:freeze)
+      end
+
+      def dup_for(new_owner)
+        self.class.new(id: id, **options, owner: new_owner)
+      end
+
+      def resolve_class(name)
+      end
+
+      def notify?(method_name)
+        handler_class.respond_to?(method_name)
+      end
+
+      def notify_now(handler, mid, *args)
+      end
+
+      def notify_later(handler, mid, *args)
+      end
+
+      def notify(mid, *args, params:, sync:)
+        clazz = params.empty? ? handler_class : handler_class.with(params)
+        sync ? notify_now(clazz, mid, *args) : notify_later(clazz, mid, *args)
+      end
+
+      def handler_class
+        return @handler_class if instance_variable_defined?(:@handler_class)
+
+        @handler_class = resolve_class(owner.name) ||
+                         superclass_handler
+      end
+
+      private
+
+      def superclass_handler
+        handler_method = "#{id}_class"
+
+        return if ActiveDelivery::Base == owner.superclass
+        return unless owner.superclass.respond_to?(handler_method)
+
+        owner.superclass.public_send(handler_method)
+      end
+    end
+  end
+end

data/lib/active_delivery/lines/mailer.rb

@@ -0,0 +1,25 @@
+module ActiveDelivery
+  module Lines
+    class Mailer < Base
+      alias mailer_class handler_class
+
+      def resolve_class(name)
+        name.gsub(/Delivery$/, "Mailer").safe_constantize
+      end
+
+      def notify?(method_name)
+        mailer_class.action_methods.include?(method_name.to_s)
+      end
+
+      def notify_now(mailer, mid, *args)
+        mailer.public_send(mid, *args).deliver_now
+      end
+
+      def notify_later(mailer, mid, *args)
+        mailer.public_send(mid, *args).deliver_later
+      end
+    end
+
+    ActiveDelivery::Base.register_line :mailer, Mailer
+  end
+end

data/lib/active_delivery/testing/rspec.rb

@@ -0,0 +1,154 @@
+module ActiveDelivery
+  class HaveDeliveredTo < RSpec::Matchers::BuiltIn::BaseMatcher
+    attr_reader :delivery_class, :event, :args, :params, :sync_value
+
+    def initialize(delivery_class, event = nil, *args)
+      @delivery_class = delivery_class
+      @event = event
+      @args = args
+      set_expected_number(:exactly, 1)
+    end
+
+    def with(params)
+      @params = params
+      self
+    end
+
+    def synchronously
+      @sync_value = true
+      self
+    end
+
+    def exactly(count)
+      set_expected_number(:exactly, count)
+      self
+    end
+
+    def at_least(count)
+      set_expected_number(:at_least, count)
+      self
+    end
+
+    def at_most(count)
+      set_expected_number(:at_most, count)
+      self
+    end
+
+    def times
+      self
+    end
+
+    def once
+      exactly(:once)
+    end
+
+    def twice
+      exactly(:twice)
+    end
+
+    def thrice
+      exactly(:thrice)
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(proc)
+      raise ArgumentError, "have_delivered_to only supports block expectations" unless Proc === proc
+
+      TestDelivery.enable { proc.call }
+
+      actual_deliveries = TestDelivery.store
+
+      @matching_deliveries, @unmatching_deliveries =
+        actual_deliveries.partition do |(delivery, actual_event, actual_args, options)|
+          next false unless delivery_class === delivery
+
+          next false unless event.nil? || event == actual_event
+          next false unless params.nil? || params === delivery.params
+
+          next false unless args.each.with_index.all? do |arg, i|
+            arg === actual_args[i]
+          end
+
+          next false if !sync_value.nil? && (options.fetch(:sync, false) != sync_value)
+
+          true
+        end
+
+      @matching_count = @matching_deliveries.size
+
+      case @expectation_type
+      when :exactly then @expected_number == @matching_count
+      when :at_most then @expected_number >= @matching_count
+      when :at_least then @expected_number <= @matching_count
+      end
+    end
+
+    def failure_message
+      (+"expected to deliver").tap do |msg|
+        msg << " :#{event} notification" if event
+        msg << " via #{delivery_class}#{sync_value ? " (sync)" : ""} with:"
+        msg << "\n - params: #{params_description(params)}" if params
+        msg << "\n - args: #{args.present? ? args : "<none>"}"
+        msg << "\n#{message_expectation_modifier}, but"
+
+        if @unmatching_deliveries.any?
+          msg << " delivered the following notifications:"
+          @unmatching_deliveries.each do |(delivery, event, args, options)|
+            msg << "\n  :#{event} via #{delivery.class}" \
+                  "#{options[:sync] ? " (sync)" : ""}" \
+                  " with:" \
+                  "\n   - params: #{delivery.params.present? ? delivery.params.to_s : "<none>"}" \
+                  "\n   - args: #{args}"
+          end
+        else
+          msg << " haven't delivered anything"
+        end
+      end
+    end
+
+    private
+
+    def set_expected_number(relativity, count)
+      @expectation_type = relativity
+      @expected_number =
+        case count
+        when :once then 1
+        when :twice then 2
+        when :thrice then 3
+        else Integer(count)
+        end
+    end
+
+    def failure_message_when_negated
+      "expected not to deliver #{event ? " :#{event} notification" : ""} via #{delivery_class}"
+    end
+
+    def message_expectation_modifier
+      number_modifier = @expected_number == 1 ? "once" : "#{@expected_number} times"
+      case @expectation_type
+      when :exactly then "exactly #{number_modifier}"
+      when :at_most then "at most #{number_modifier}"
+      when :at_least then "at least #{number_modifier}"
+      end
+    end
+
+    def params_description(data)
+      if data.is_a?(RSpec::Matchers::Composable)
+        data.description
+      else
+        data
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def have_delivered_to(*args)
+      ActiveDelivery::HaveDeliveredTo.new(*args)
+    end
+  end)
+end

data/lib/active_delivery/testing.rb

@@ -0,0 +1,46 @@
+module ActiveDelivery
+  module TestDelivery
+    class << self
+      def enable
+        raise ArgumentError, "block is reauired" unless block_given?
+        begin
+          clear
+          Thread.current[:active_delivery_testing] = true
+          yield
+        ensure
+          Thread.current[:active_delivery_testing] = false
+        end
+      end
+
+      def enabled?
+        Thread.current[:active_delivery_testing] == true
+      end
+
+      def track(delivery, event, args, options)
+        store << [delivery, event, args, options]
+      end
+
+      def store
+        @store ||= []
+      end
+
+      def clear
+        store.clear
+      end
+    end
+
+    def notify(event, *args, **options)
+      return super unless test?
+      TestDelivery.track(self, event, args, options)
+      nil
+    end
+
+    def test?
+      TestDelivery.enabled?
+    end
+  end
+end
+
+ActiveDelivery::Base.prepend ActiveDelivery::TestDelivery
+
+require "active_delivery/testing/rspec" if defined?(RSpec)

data/lib/active_delivery/version.rb

@@ -1,3 +1,3 @@
 module ActiveDelivery
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/active_delivery.rb

@@ -1,5 +1,8 @@
 require "active_delivery/version"
+require "active_delivery/base"
+require "active_delivery/callbacks" if defined?(ActiveSupport)
 
-module ActiveDelivery
-  # Your code goes here...
-end
+require "active_delivery/lines/base"
+require "active_delivery/lines/mailer" if defined?(ActionMailer)
+
+require "active_delivery/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: active_delivery
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 2018-12-20 00:00:00.000000000 Z
 dependencies:
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.12
 description: Rails framework for managing all types of notifications in one place
 email:
 - dementiev.vm@gmail.com
@@ -62,6 +76,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -69,7 +84,15 @@ files:
 - active_delivery.gemspec
 - bin/console
 - bin/setup
+- gemfiles/rails42.gemfile
+- gemfiles/railsmaster.gemfile
 - lib/active_delivery.rb
+- lib/active_delivery/base.rb
+- lib/active_delivery/callbacks.rb
+- lib/active_delivery/lines/base.rb
+- lib/active_delivery/lines/mailer.rb
+- lib/active_delivery/testing.rb
+- lib/active_delivery/testing/rspec.rb
 - lib/active_delivery/version.rb
 homepage: https://github.com/palkan/active_delivery
 licenses: