sanitize_email 2.0.0 → 2.0.1

data/lib/sanitize_email/railtie.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
 module SanitizeEmail
   # For Rails 3.0, which didn't yet support Engines
   class Railtie < ::Rails::Railtie
-
     config.after_initialize do
       ActionMailer::Base.register_interceptor(SanitizeEmail::Bleach)
     end
-
   end
 end

data/lib/sanitize_email/rspec_matchers.rb

@@ -1,47 +1,49 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 # Note: the RspecMatchers are composed matchers:
 # See: http://www.relishapp.com/rspec/rspec-expectations/v/3-5/docs/composing-matchers
 
-require "sanitize_email/mail_ext"
+require 'sanitize_email/mail_ext'
 
 module SanitizeEmail
   # Provides matchers that can be used in
   #   Rspec tests to assert the behavior of email
   module RspecMatchers
-    [:from, :to, :cc, :bcc, :subject, :reply_to].each do |attribute|
+    %i[from to cc bcc subject reply_to].each do |attribute|
       RSpec::Matchers.define "have_#{attribute}" do |matcher|
         match do |actual|
           @actual = actual.send(attribute)
-          @actual = @actual.join(", ") if @actual.respond_to?(:join)
+          @actual = @actual.join(', ') if @actual.respond_to?(:join)
           expect(@actual).to match(matcher)
         end
       end
     end
 
-    [:from, :to, :cc, :bcc, :subject, :reply_to].each do |attribute|
+    %i[from to cc bcc subject reply_to].each do |attribute|
       RSpec::Matchers.define "match_#{attribute}" do |matcher|
         match do |actual|
           @actual = actual.send(attribute)
-          @actual = @actual.join(", ") if @actual.respond_to?(:join)
+          @actual = @actual.join(', ') if @actual.respond_to?(:join)
           expect(@actual).to match(matcher)
         end
       end
     end
 
-    [:from, :to, :cc, :bcc, :subject, :reply_to].each do |attribute|
+    %i[from to cc bcc subject reply_to].each do |attribute|
       RSpec::Matchers.define "be_#{attribute}" do |matcher|
         match do |actual|
           @actual = actual.send(attribute)
-          @actual = @actual.join(", ") if @actual.respond_to?(:join)
+          @actual = @actual.join(', ') if @actual.respond_to?(:join)
           expect(@actual).to be(matcher)
         end
       end
     end
 
-    RSpec::Matchers.define "have_to_username" do |matcher|
+    RSpec::Matchers.define 'have_to_username' do |matcher|
       def get_to_username(email_message)
-        username_header = email_message.header["X-Sanitize-Email-To"]
+        username_header = email_message.header['X-Sanitize-Email-To']
         return username_header unless username_header.is_a?(Mail::Field)
         email_message.header.fields[3].value
       end
@@ -51,9 +53,9 @@ module SanitizeEmail
       end
     end
 
-    RSpec::Matchers.define "have_cc_username" do |matcher|
+    RSpec::Matchers.define 'have_cc_username' do |matcher|
       def get_cc_username(email_message)
-        username_header = email_message.header["X-Sanitize-Email-Cc"]
+        username_header = email_message.header['X-Sanitize-Email-Cc']
         return username_header unless username_header.is_a?(Mail::Field)
         email_message.header.fields[3].value
       end
@@ -64,13 +66,13 @@ module SanitizeEmail
     end
 
     # Cribbed from email_spec gem
-    RSpec::Matchers.define "have_body_text" do |matcher|
+    RSpec::Matchers.define 'have_body_text' do |matcher|
       def get_fuzzy_body(email_message)
-        email_message.default_part_body.to_s.gsub(/\s+/, " ")
+        email_message.default_part_body.to_s.gsub(/\s+/, ' ')
       end
 
       def get_fuzzy_matcher(to_fuzz)
-        to_fuzz.gsub(/\s+/, " ")
+        to_fuzz.gsub(/\s+/, ' ')
       end
       match do |actual|
         @actual = get_fuzzy_body(actual)
@@ -80,13 +82,12 @@ module SanitizeEmail
     end
 
     # Cribbed from email_spec gem
-    RSpec::Matchers.define "have_header" do |name, matcher|
+    RSpec::Matchers.define 'have_header' do |name, matcher|
       match do |actual|
         @actual = actual.header[name]
         @actual = @actual.value unless @actual.nil?
         expect(@actual).to match(matcher)
       end
     end
-
   end
 end

data/lib/sanitize_email/test_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 # Note: the RspecMatchers no longer use these methods.  Instead they are composed matchers:
@@ -6,7 +8,6 @@
 module SanitizeEmail
   # Helpers for test-unit
   module TestHelpers
-
     # Error raised when unable to match an expected part of email in order to fail the test
     class UnexpectedMailType < StandardError; end
 
@@ -15,20 +16,18 @@ module SanitizeEmail
     end
 
     def string_matching(matcher, part, attribute)
-      if attribute.respond_to?(:=~) # Can we match a regex against it?
-        if matcher.is_a?(Regexp)
-          attribute =~ matcher
-        else
-          attribute =~ Regexp.new(Regexp.escape(matcher))
-        end
-      else
-        raise UnexpectedMailType, "Cannot match #{matcher} for #{part}"
-      end
+      # Can we match a regex against it?
+      raise UnexpectedMailType, "Cannot match #{matcher} for #{part}" unless attribute.respond_to?(:=~)
+      attribute =~ if matcher.is_a?(Regexp)
+                     matcher
+                   else
+                     Regexp.new(Regexp.escape(matcher))
+                   end
     end
 
     # Normalize arrays to strings
     def array_matching(matcher, part, attribute)
-      attribute = attribute.join(", ") if attribute.respond_to?(:join)
+      attribute = attribute.join(', ') if attribute.respond_to?(:join)
       string_matching(matcher, part, attribute)
     end
 
@@ -39,6 +38,5 @@ module SanitizeEmail
     def email_attribute_matching(matcher, part, attribute)
       array_matching(matcher, part, attribute)
     end
-
   end
 end

data/lib/sanitize_email/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
 module SanitizeEmail
-  VERSION = "2.0.0".freeze
+  VERSION = '2.0.1'
 end

data/sanitize_email.gemspec

@@ -1,47 +1,49 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/sanitize_email/version', __FILE__)
+
+# frozen_string_literal: true
+
+require File.expand_path('lib/sanitize_email/version', __dir__)
 
 Gem::Specification.new do |s|
-  s.name = "sanitize_email"
+  s.name = 'sanitize_email'
   s.version = SanitizeEmail::VERSION
 
-  s.authors = ["Peter Boling", "John Trupiano", "George Anderson"]
-  s.summary = "Email Condom for your Ruby Server"
-  s.description = <<EOS
-  Email Condom for your Ruby Server.
-In Rails, Sinatra, et al, or simply the mail gem: Aids in development, testing, qa, and production troubleshooting of email issues without worrying that emails will get sent to actual live addresses.
-EOS
-  s.email = ["peter.boling@gmail.com"]
+  s.authors = ['Peter Boling', 'John Trupiano', 'George Anderson']
+  s.summary = 'Email Condom for your Ruby Server'
+  s.description = <<~DESCRIPTION
+      Email Condom for your Ruby Server.
+    In Rails, Sinatra, et al, or simply the mail gem: Aids in development, testing, qa, and production troubleshooting of email issues without worrying that emails will get sent to actual live addresses.
+DESCRIPTION
+  s.email = ['peter.boling@gmail.com']
   s.extra_rdoc_files = [
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md"
+    'CHANGELOG.md',
+    'LICENSE',
+    'README.md',
   ]
-  s.files         = `git ls-files`.split($\)
-  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  s.executables   = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
-  s.homepage = "http://github.com/pboling/sanitize_email"
-  s.licenses = ["MIT"]
-  s.email = 'peter.boling@gmail.com'
-  s.require_paths = ["lib"]
+  s.homepage = 'http://github.com/pboling/sanitize_email'
+  s.licenses = ['MIT']
+  s.require_paths = ['lib']
   s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.3.0'
 
   # Runtime Dependencies
   # A project wanting to use this gem's engine/railtie will be expected to have already loaded the rails/railtie gem.
-  #s.add_dependency "railties", ">= 3.2"
+  # s.add_dependency "railties", ">= 3.2"
   # to replace the cattr_accessor method we lost when removing rails from run time dependencies
-  #s.add_runtime_dependency("facets", ["> 0"])
+  # s.add_runtime_dependency("facets", ["> 0"])
 
   # Development Dependencies
-  s.add_development_dependency "bundler"
-  s.add_development_dependency("rails", [">= 3.0.20", "< 6"])
-  s.add_development_dependency("actionmailer", [">= 3"])
-  s.add_development_dependency("rspec", [">= 3"])
-  s.add_development_dependency("mail", [">= 0"])
-  s.add_development_dependency("rdoc", [">= 3.12"])
-  s.add_development_dependency("rake", [">= 12"])
-  s.add_development_dependency("pry", [">= 0"])
-  s.add_development_dependency("appraisal")
-  s.add_development_dependency("wwtd")
-  s.add_development_dependency("coveralls")
+  s.add_development_dependency('actionmailer', ['>= 3'])
+  s.add_development_dependency('appraisal')
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency('byebug', ['>= 0'])
+  s.add_development_dependency('coveralls')
+  s.add_development_dependency('mail', ['>= 0'])
+  s.add_development_dependency('rails', ['>= 3.2', '< 6'])
+  s.add_development_dependency('rake', ['>= 12'])
+  s.add_development_dependency('rdoc', ['>= 3.12'])
+  s.add_development_dependency('rspec', ['>= 3'])
+  s.add_development_dependency('wwtd')
 end

data/spec/sanitize_email_spec.rb

@@ -1,34 +1,32 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
-require "spec_helper"
+require 'spec_helper'
 
 describe SanitizeEmail do
   DEFAULT_TEST_CONFIG = {
-    sanitized_cc:  "cc@sanitize_email.org",
-    sanitized_bcc: "bcc@sanitize_email.org",
-    use_actual_email_prepended_to_subject: false,
-    use_actual_environment_prepended_to_subject: false,
-    use_actual_email_as_sanitized_user_name: false
+    :sanitized_cc => 'cc@sanitize_email.org',
+    :sanitized_bcc => 'bcc@sanitize_email.org',
+    :use_actual_email_prepended_to_subject => false,
+    :use_actual_environment_prepended_to_subject => false,
+    :use_actual_email_as_sanitized_user_name => false,
   }.freeze
 
-  before(:all) do
-    SanitizeEmail::Deprecation.deprecate_in_silence = true
-  end
-
   # Cleanup, so tests don't bleed
-  after(:each) do
+  after do
     SanitizeEmail::Config.config = SanitizeEmail::Config::DEFAULTS
-    SanitizeEmail.force_sanitize = nil
+    described_class.force_sanitize = nil
     Mail.class_variable_get(:@@delivery_interceptors).pop
   end
 
-  def sanitize_spec_dryer(rails_env = "test")
-    logger = Logger.new($stdout).tap do |logger|
-      logger.level = 5 # Unknown (make it silent!)
+  def sanitize_spec_dryer(rails_env = 'test')
+    logger = Logger.new($stdout).tap do |logsy|
+      logsy.level = 5 # Unknown (make it silent!)
     end
 
     Mail.defaults do
-      delivery_method :logger, logger: logger, severity: :info
+      delivery_method :logger, :logger => logger, :severity => :info
     end
     SanitizeEmail::Config.instance_variable_set(
       :@config,
@@ -40,8 +38,13 @@ describe SanitizeEmail do
   def configure_sanitize_email(sanitize_hash = {})
     options = DEFAULT_TEST_CONFIG.merge(sanitize_hash).dup
     unless sanitize_hash.key?(:sanitized_recipients)
-      options.reverse_merge!(sanitized_to: "to@sanitize_email.org")
+      options.reverse_merge!(:sanitized_to => 'to@sanitize_email.org')
     end
+    configure_from_options(options)
+    Mail.register_interceptor(SanitizeEmail::Bleach)
+  end
+
+  def configure_from_options(options)
     SanitizeEmail::Config.configure do |config|
       config[:engage] = options[:engage]
       config[:environment] = options[:environment]
@@ -49,39 +52,29 @@ describe SanitizeEmail do
       config[:sanitized_to] = options[:sanitized_to]
       config[:sanitized_cc] = options[:sanitized_cc]
       config[:sanitized_bcc] = options[:sanitized_bcc]
-      config[:use_actual_email_prepended_to_subject] =
-        options[:use_actual_email_prepended_to_subject]
-      config[:use_actual_environment_prepended_to_subject] =
-        options[:use_actual_environment_prepended_to_subject]
-      config[:use_actual_email_as_sanitized_user_name] =
-        options[:use_actual_email_as_sanitized_user_name]
+      config[:use_actual_email_prepended_to_subject] = options[:use_actual_email_prepended_to_subject]
+      config[:use_actual_environment_prepended_to_subject] = options[:use_actual_environment_prepended_to_subject]
+      config[:use_actual_email_as_sanitized_user_name] = options[:use_actual_email_as_sanitized_user_name]
 
       # For testing *deprecated* configuration options:
-      if options[:local_environments]
-        config[:local_environments] = options[:local_environments]
-      end
-      if options[:sanitized_recipients]
-        config[:sanitized_recipients] = options[:sanitized_recipients]
-      end
-      unless options[:force_sanitize].nil?
-        config[:force_sanitize] = options[:force_sanitize]
-      end
+      config[:local_environments] = options[:local_environments] if options[:local_environments]
+      config[:sanitized_recipients] = options[:sanitized_recipients] if options[:sanitized_recipients]
+      config[:force_sanitize] = options[:force_sanitize] unless options[:force_sanitize].nil?
     end
-    Mail.register_interceptor(SanitizeEmail::Bleach)
   end
 
   def funky_config
     SanitizeEmail::Config.configure do |config|
       config[:sanitized_to] =
-        %w(
-             funky@sanitize_email.org
-             yummy@sanitize_email.org
-             same@example.org
-          )
+        %w[
+          funky@sanitize_email.org
+          yummy@sanitize_email.org
+          same@example.org
+        ]
       config[:sanitized_cc] = nil
       config[:sanitized_bcc] = nil
       # logic to turn sanitize_email on and off goes in this Proc:
-      config[:activation_proc] = proc { Rails.env != "production" }
+      config[:activation_proc] = proc { Rails.env != 'production' }
       config[:use_actual_email_prepended_to_subject] = true
       config[:use_actual_environment_prepended_to_subject] = true
       config[:use_actual_email_as_sanitized_user_name] = false
@@ -115,502 +108,503 @@ describe SanitizeEmail do
 
   def mail_delivery_frozen_strings
     @email_message = Mail.deliver do
-      from      "from@example.org".freeze
-      to        "to@example.org".freeze
-      subject   "original subject".freeze
-      body      "funky fresh".freeze
+      from      'from@example.org'
+      to        'to@example.org'
+      subject   'original subject'
+      body      'funky fresh'
     end
   end
 
   def mail_delivery_hot_mess
     @email_message = Mail.deliver do
-      from      "same@example.org"
-      to        %w(
-                    same@example.org
-                    same@example.org
-                    same@example.org
-                    same@example.org
-                    same@example.org
-                  )
-      cc        "same@example.org"
-      bcc       "same@example.org"
-      reply_to  "same@example.org"
-      subject   "original subject"
-      body      "funky fresh"
+      from      'same@example.org'
+      to        %w[
+        same@example.org
+        same@example.org
+        same@example.org
+        same@example.org
+        same@example.org
+      ]
+      cc        'same@example.org'
+      bcc       'same@example.org'
+      reply_to  'same@example.org'
+      subject   'original subject'
+      body      'funky fresh'
     end
   end
 
   def mail_delivery
     @email_message = Mail.deliver do
-      from      "from@example.org"
-      to        "to@example.org"
-      cc        "cc@example.org"
-      bcc       "bcc@example.org"
-      reply_to  "reply_to@example.org"
-      subject   "original subject"
-      body      "funky fresh"
+      from      'from@example.org'
+      to        'to@example.org'
+      cc        'cc@example.org'
+      bcc       'bcc@example.org'
+      reply_to  'reply_to@example.org'
+      subject   'original subject'
+      body      'funky fresh'
     end
   end
 
   def mail_delivery_multiple_recipients
     @email_message = Mail.deliver do
-      from      "from@example.org"
-      to        %w( to1@example.org to2@example.org to3@example.org )
-      cc        %w( cc1@example.org cc2@example.org cc3@example.org )
-      bcc       %w( bcc1@example.org bcc2@example.org bcc3@example.org )
-      reply_to  "reply_to@example.org"
-      subject   "original subject"
-      body      "funky fresh"
+      from      'from@example.org'
+      to        %w[to1@example.org to2@example.org to3@example.org]
+      cc        %w[cc1@example.org cc2@example.org cc3@example.org]
+      bcc       %w[bcc1@example.org bcc2@example.org bcc3@example.org]
+      reply_to  'reply_to@example.org'
+      subject   'original subject'
+      body      'funky fresh'
     end
   end
 
-  before(:each) do
+  before do
+    SanitizeEmail::Deprecation.deprecate_in_silence = true
     sanitize_spec_dryer
   end
 
-  context "module methods" do
-    context "unsanitary" do
-      before(:each) do
+  context 'module methods' do
+    context 'unsanitary' do
+      before do
         configure_sanitize_email
         unsanitary_mail_delivery
       end
-      it "should not alter non-sanitized attributes" do
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_reply_to("reply_to@example.org")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'does not alter non-sanitized attributes' do
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_reply_to('reply_to@example.org')
+        expect(@email_message).to have_body_text('funky fresh')
       end
-      it "should not prepend overrides" do
+      it 'does not prepend overrides' do
         expect(@email_message).not_to have_to_username(
-          "to at sanitize_email.org"
+          'to at sanitize_email.org'
         )
         expect(@email_message).not_to have_subject(
-          "(to at sanitize_email.org)"
+          '(to at sanitize_email.org)'
         )
       end
-      it "alters nothing" do
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_reply_to("reply_to@example.org")
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_to("to@example.org")
-        expect(@email_message).not_to have_to_username("to at")
-        expect(@email_message).to have_cc("cc@example.org")
-        expect(@email_message).to have_bcc("bcc@example.org")
-        expect(@email_message).to have_subject("original subject")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'alters nothing' do
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_reply_to('reply_to@example.org')
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_to('to@example.org')
+        expect(@email_message).not_to have_to_username('to at')
+        expect(@email_message).to have_cc('cc@example.org')
+        expect(@email_message).to have_bcc('bcc@example.org')
+        expect(@email_message).to have_subject('original subject')
+        expect(@email_message).to have_body_text('funky fresh')
       end
     end
 
-    context "sanitary" do
-      before(:each) do
+    context 'sanitary' do
+      before do
         configure_sanitize_email
         sanitary_mail_delivery
       end
-      it "should not alter non-sanitized attributes" do
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_reply_to("reply_to@example.org")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'does not alter non-sanitized attributes' do
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_reply_to('reply_to@example.org')
+        expect(@email_message).to have_body_text('funky fresh')
       end
-      it "should not prepend overrides" do
+      it 'does not prepend overrides' do
         expect(@email_message).not_to have_to_username(
-          "to at sanitize_email.org"
+          'to at sanitize_email.org'
         )
         expect(@email_message).not_to have_subject(
-          "(to at sanitize_email.org)"
+          '(to at sanitize_email.org)'
         )
       end
-      it "should override" do
-        expect(@email_message).to have_to("to@sanitize_email.org")
-        expect(@email_message).to have_cc("cc@sanitize_email.org")
-        expect(@email_message).to have_bcc("bcc@sanitize_email.org")
+      it 'overrides' do
+        expect(@email_message).to have_to('to@sanitize_email.org')
+        expect(@email_message).to have_cc('cc@sanitize_email.org')
+        expect(@email_message).to have_bcc('bcc@sanitize_email.org')
       end
-      it "should set headers" do
+      it 'sets headers' do
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To",
-          "to@example.org"
+          'X-Sanitize-Email-To',
+          'to@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc",
-          "cc@example.org"
+          'X-Sanitize-Email-Cc',
+          'cc@example.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "bcc@sanitize_email.org"
+          'X-Sanitize-Email-Bcc',
+          'bcc@sanitize_email.org'
         )
       end
-      it "should not prepend originals by default" do
+      it 'does not prepend originals by default' do
         expect(@email_message).not_to have_to_username(
-          "to at example.org <to@sanitize_email.org>"
+          'to at example.org <to@sanitize_email.org>'
         )
         expect(@email_message).not_to have_subject(
-          "(to at example.org) original subject"
+          '(to at example.org) original subject'
         )
       end
     end
 
-    context "sanitary with multiple recipients" do
-      before(:each) do
+    context 'sanitary with multiple recipients' do
+      before do
         configure_sanitize_email
         sanitary_mail_delivery_multiple_recipients
       end
-      it "should not alter non-sanitized attributes" do
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_reply_to("reply_to@example.org")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'does not alter non-sanitized attributes' do
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_reply_to('reply_to@example.org')
+        expect(@email_message).to have_body_text('funky fresh')
       end
-      it "should not prepend overrides" do
+      it 'does not prepend overrides' do
         expect(@email_message).not_to have_to_username(
-          "to at sanitize_email.org"
+          'to at sanitize_email.org'
         )
-        expect(@email_message).not_to have_subject("(to at sanitize_email.org)")
+        expect(@email_message).not_to have_subject('(to at sanitize_email.org)')
       end
-      it "should override" do
-        expect(@email_message).to have_to("to@sanitize_email.org")
-        expect(@email_message).to have_cc("cc@sanitize_email.org")
-        expect(@email_message).to have_bcc("bcc@sanitize_email.org")
+      it 'overrides' do
+        expect(@email_message).to have_to('to@sanitize_email.org')
+        expect(@email_message).to have_cc('cc@sanitize_email.org')
+        expect(@email_message).to have_bcc('bcc@sanitize_email.org')
       end
-      it "should set headers for sanitized :to recipients" do
+      it 'sets headers for sanitized :to recipients' do
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To",
-          "to1@example.org"
+          'X-Sanitize-Email-To',
+          'to1@example.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-To-0",
-          "to1@example.org"
+          'X-Sanitize-Email-To-0',
+          'to1@example.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-To-1",
-          "to1@example.org"
+          'X-Sanitize-Email-To-1',
+          'to1@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To-2",
-          "to2@example.org"
+          'X-Sanitize-Email-To-2',
+          'to2@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To-3",
-          "to3@example.org"
+          'X-Sanitize-Email-To-3',
+          'to3@example.org'
         )
       end
-      it "should set headers for sanitized :cc recipients" do
+      it 'sets headers for sanitized :cc recipients' do
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc",
-          "cc1@example.org"
+          'X-Sanitize-Email-Cc',
+          'cc1@example.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Cc-0",
-          "cc1@example.org"
+          'X-Sanitize-Email-Cc-0',
+          'cc1@example.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Cc-1",
-          "cc1@example.org"
+          'X-Sanitize-Email-Cc-1',
+          'cc1@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc-2",
-          "cc2@example.org"
+          'X-Sanitize-Email-Cc-2',
+          'cc2@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc-3",
-          "cc3@example.org"
+          'X-Sanitize-Email-Cc-3',
+          'cc3@example.org'
         )
       end
-      it "should not set headers for sanitized :bcc recipients" do
+      it 'does not set headers for sanitized :bcc recipients' do
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "bcc1@sanitize_email.org"
+          'X-Sanitize-Email-Bcc',
+          'bcc1@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc-0",
-          "bcc1@sanitize_email.org"
+          'X-Sanitize-Email-Bcc-0',
+          'bcc1@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc-1",
-          "bcc1@sanitize_email.org"
+          'X-Sanitize-Email-Bcc-1',
+          'bcc1@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc-2",
-          "bcc2@sanitize_email.org"
+          'X-Sanitize-Email-Bcc-2',
+          'bcc2@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc-3",
-          "bcc3@sanitize_email.org"
+          'X-Sanitize-Email-Bcc-3',
+          'bcc3@sanitize_email.org'
         )
       end
-      it "should not prepend originals by default" do
+      it 'does not prepend originals by default' do
         expect(@email_message).not_to have_to_username(
-          "to at example.org <to@sanitize_email.org>"
+          'to at example.org <to@sanitize_email.org>'
         )
         expect(@email_message).not_to have_subject(
-          "(to at example.org) original subject"
+          '(to at example.org) original subject'
         )
       end
     end
 
-    context "sanitary with funky config" do
-      before(:each) do
+    context 'sanitary with funky config' do
+      before do
         funky_config
-        SanitizeEmail.force_sanitize = true
+        described_class.force_sanitize = true
         mail_delivery
       end
-      it "original to is prepended to subject" do
+      it 'original to is prepended to subject' do
         regex = /\(to at example.org\).*original subject/
         expect(@email_message).to have_subject(regex)
       end
-      it "original to is only prepended once to subject" do
+      it 'original to is only prepended once to subject' do
         regex = /\(to at example.org\).*\(to at example.org\).*original subject/
         expect(@email_message).not_to have_subject(regex)
       end
-      it "should not alter non-sanitized attributes" do
-        expect(@email_message).to have_from("from@example.org")
-        expect(@email_message).to have_reply_to("reply_to@example.org")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'does not alter non-sanitized attributes' do
+        expect(@email_message).to have_from('from@example.org')
+        expect(@email_message).to have_reply_to('reply_to@example.org')
+        expect(@email_message).to have_body_text('funky fresh')
       end
-      it "should not prepend overrides" do
+      it 'does not prepend overrides' do
         expect(@email_message).not_to have_to_username(
-          "to at sanitize_email.org"
+          'to at sanitize_email.org'
         )
         regex = /.*\(to at sanitize_email.org\).*/
         expect(@email_message).not_to have_subject(regex)
       end
-      it "should override where original recipients were not nil" do
-        expect(@email_message).to have_to("funky@sanitize_email.org")
+      it 'overrides where original recipients were not nil' do
+        expect(@email_message).to have_to('funky@sanitize_email.org')
       end
-      it "should not override where original recipients were nil" do
-        expect(@email_message).not_to have_cc("cc@sanitize_email.org")
-        expect(@email_message).not_to have_bcc("bcc@sanitize_email.org")
+      it 'does not override where original recipients were nil' do
+        expect(@email_message).not_to have_cc('cc@sanitize_email.org')
+        expect(@email_message).not_to have_bcc('bcc@sanitize_email.org')
       end
-      it "should set headers of originals" do
+      it 'sets headers of originals' do
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To",
-          "to@example.org"
+          'X-Sanitize-Email-To',
+          'to@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc",
-          "cc@example.org"
+          'X-Sanitize-Email-Cc',
+          'cc@example.org'
         )
       end
-      it "should not set headers of bcc" do
+      it 'does not set headers of bcc' do
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "bcc@sanitize_email.org"
+          'X-Sanitize-Email-Bcc',
+          'bcc@sanitize_email.org'
         )
       end
-      it "should not set headers of overrides" do
+      it 'does not set headers of overrides' do
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-To",
-          "funky@sanitize_email.org"
+          'X-Sanitize-Email-To',
+          'funky@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Cc",
-          "cc@sanitize_email.org"
+          'X-Sanitize-Email-Cc',
+          'cc@sanitize_email.org'
         )
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "bcc@sanitize_email.org"
+          'X-Sanitize-Email-Bcc',
+          'bcc@sanitize_email.org'
         )
-        #puts "email headers:\n#{@email_message.header}"
+        # puts "email headers:\n#{@email_message.header}"
       end
-      it "should not prepend originals by default" do
+      it 'does not prepend originals by default' do
         expect(@email_message).not_to have_to_username(
-          "to at example.org <to@sanitize_email.org>"
+          'to at example.org <to@sanitize_email.org>'
         )
         expect(@email_message).not_to have_subject(
-          "(to at example.org) original subject"
+          '(to at example.org) original subject'
         )
       end
     end
 
-    context "sanitary with funky config and hot mess delivery" do
-      before(:each) do
+    context 'sanitary with funky config and hot mess delivery' do
+      before do
         funky_config
-        SanitizeEmail.force_sanitize = true
+        described_class.force_sanitize = true
         mail_delivery_hot_mess
       end
-      it "original to is prepended to subject" do
+      it 'original to is prepended to subject' do
         regex = /\(same at example.org\).*original subject/
         expect(@email_message).to match_subject(regex)
       end
-      it "original to is only prepended once to subject" do
+      it 'original to is only prepended once to subject' do
         regex = /\(same at example.org\).*\(same at example.org\).*original subject/
         expect(@email_message).not_to match_subject(regex)
       end
-      it "should not alter non-sanitized attributes" do
-        expect(@email_message).to have_from("same@example.org")
-        expect(@email_message).to have_reply_to("same@example.org")
-        expect(@email_message).to have_body_text("funky fresh")
+      it 'does not alter non-sanitized attributes' do
+        expect(@email_message).to have_from('same@example.org')
+        expect(@email_message).to have_reply_to('same@example.org')
+        expect(@email_message).to have_body_text('funky fresh')
       end
-      it "should not prepend overrides" do
-        expect(@email_message).not_to have_to_username("same at example.org")
+      it 'does not prepend overrides' do
+        expect(@email_message).not_to have_to_username('same at example.org')
       end
-      it "should override where original recipients were not nil" do
-        expect(@email_message).to have_to("same@example.org")
+      it 'overrides where original recipients were not nil' do
+        expect(@email_message).to have_to('same@example.org')
       end
-      it "should not override where original recipients were nil" do
-        expect(@email_message).not_to have_cc("same@example.org")
-        expect(@email_message).not_to have_bcc("same@example.org")
+      it 'does not override where original recipients were nil' do
+        expect(@email_message).not_to have_cc('same@example.org')
+        expect(@email_message).not_to have_bcc('same@example.org')
       end
-      it "should set headers of originals" do
+      it 'sets headers of originals' do
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-To",
-          "same@example.org"
+          'X-Sanitize-Email-To',
+          'same@example.org'
         )
         expect(@email_message).to have_header(
-          "X-Sanitize-Email-Cc",
-          "same@example.org"
+          'X-Sanitize-Email-Cc',
+          'same@example.org'
         )
       end
-      it "should not set headers of bcc" do
+      it 'does not set headers of bcc' do
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "same@example.org"
+          'X-Sanitize-Email-Bcc',
+          'same@example.org'
         )
       end
-      it "should not set headers of overrides" do
+      it 'does not set headers of overrides' do
         expect(@email_message).not_to have_header(
-          "X-Sanitize-Email-Bcc",
-          "same@example.org"
+          'X-Sanitize-Email-Bcc',
+          'same@example.org'
         )
         # puts "email headers:\n#{@email_message.header}"
       end
-      it "should not prepend originals by default" do
+      it 'does not prepend originals by default' do
         expect(@email_message).not_to have_to_username(
-          "same at example.org <same@example.org>"
+          'same at example.org <same@example.org>'
         )
         expect(@email_message).not_to have_subject(
-          "(same at example.org) original subject"
+          '(same at example.org) original subject'
         )
       end
     end
 
-    context "with frozen string (literals)" do
-      it "prepends strings without exception" do
+    context 'with frozen string (literals)' do
+      it 'prepends strings without exception' do
         configure_sanitize_email(
-          environment: "{{serverABC}}",
-          use_actual_environment_prepended_to_subject: true
+          :environment => '{{serverABC}}',
+          :use_actual_environment_prepended_to_subject => true
         )
-        expect { sanitary_mail_delivery_frozen_strings }.to_not raise_exception
+        expect { sanitary_mail_delivery_frozen_strings }.not_to raise_exception
       end
     end
 
-    context "force_sanitize" do
-      context "true" do
-        before(:each) do
+    context 'force_sanitize' do
+      context 'true' do
+        before do
           # Should turn off sanitization using the force_sanitize
-          configure_sanitize_email(activation_proc: proc { true })
-          SanitizeEmail.force_sanitize = true
+          configure_sanitize_email(:activation_proc => proc { true })
+          described_class.force_sanitize = true
           mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should override" do
-          expect(@email_message).to have_to("to@sanitize_email.org")
-          expect(@email_message).to have_cc("cc@sanitize_email.org")
-          expect(@email_message).to have_bcc("bcc@sanitize_email.org")
+        it 'overrides' do
+          expect(@email_message).to have_to('to@sanitize_email.org')
+          expect(@email_message).to have_cc('cc@sanitize_email.org')
+          expect(@email_message).to have_bcc('bcc@sanitize_email.org')
         end
-        it "should set headers" do
+        it 'sets headers' do
           expect(@email_message).to have_header(
-            "X-Sanitize-Email-To",
-            "to@example.org"
+            'X-Sanitize-Email-To',
+            'to@example.org'
           )
           expect(@email_message).to have_header(
-            "X-Sanitize-Email-Cc",
-            "cc@example.org"
+            'X-Sanitize-Email-Cc',
+            'cc@example.org'
           )
           expect(@email_message).not_to have_header(
-            "X-Sanitize-Email-Bcc",
-            "bcc@sanitize_email.org"
+            'X-Sanitize-Email-Bcc',
+            'bcc@sanitize_email.org'
           )
         end
       end
-      context "false" do
-        before(:each) do
+      context 'false' do
+        before do
           # Should turn off sanitization using the force_sanitize
-          configure_sanitize_email(activation_proc: proc { true })
-          SanitizeEmail.force_sanitize = false
+          configure_sanitize_email(:activation_proc => proc { true })
+          described_class.force_sanitize = false
           mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not alter normally sanitized attributes" do
-          expect(@email_message).to have_to("to@example.org")
-          expect(@email_message).to have_cc("cc@example.org")
-          expect(@email_message).to have_bcc("bcc@example.org")
+        it 'does not alter normally sanitized attributes' do
+          expect(@email_message).to have_to('to@example.org')
+          expect(@email_message).to have_cc('cc@example.org')
+          expect(@email_message).to have_bcc('bcc@example.org')
           expect(@email_message).not_to have_header(
-            "X-Sanitize-Email-To",
-            "to@example.org"
+            'X-Sanitize-Email-To',
+            'to@example.org'
           )
           expect(@email_message).not_to have_header(
-            "X-Sanitize-Email-Cc",
-            "cc@example.org"
+            'X-Sanitize-Email-Cc',
+            'cc@example.org'
           )
           expect(@email_message).not_to have_header(
-            "X-Sanitize-Email-Bcc",
-            "bcc@example.org"
+            'X-Sanitize-Email-Bcc',
+            'bcc@example.org'
           )
         end
       end
-      context "nil" do
-        context "activation proc enables" do
-          before(:each) do
+      context 'nil' do
+        context 'activation proc enables' do
+          before do
             # Should ignore force_sanitize setting
-            configure_sanitize_email(activation_proc: proc { true })
-            SanitizeEmail.force_sanitize = nil
+            configure_sanitize_email(:activation_proc => proc { true })
+            described_class.force_sanitize = nil
             mail_delivery
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should override" do
-            expect(@email_message).to have_to("to@sanitize_email.org")
-            expect(@email_message).to have_cc("cc@sanitize_email.org")
-            expect(@email_message).to have_bcc("bcc@sanitize_email.org")
+          it 'overrides' do
+            expect(@email_message).to have_to('to@sanitize_email.org')
+            expect(@email_message).to have_cc('cc@sanitize_email.org')
+            expect(@email_message).to have_bcc('bcc@sanitize_email.org')
             expect(@email_message).to have_header(
-              "X-Sanitize-Email-To",
-              "to@example.org"
+              'X-Sanitize-Email-To',
+              'to@example.org'
             )
             expect(@email_message).to have_header(
-              "X-Sanitize-Email-Cc",
-              "cc@example.org"
+              'X-Sanitize-Email-Cc',
+              'cc@example.org'
             )
             expect(@email_message).not_to have_header(
-              "X-Sanitize-Email-Bcc",
-              "bcc@sanitize_email.org"
+              'X-Sanitize-Email-Bcc',
+              'bcc@sanitize_email.org'
             )
           end
         end
-        context "activation proc disables" do
-          before(:each) do
+        context 'activation proc disables' do
+          before do
             # Should ignore force_sanitize setting
-            configure_sanitize_email(activation_proc: proc { false })
-            SanitizeEmail.force_sanitize = nil
+            configure_sanitize_email(:activation_proc => proc { false })
+            described_class.force_sanitize = nil
             mail_delivery
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should not alter normally sanitized attributes" do
-            expect(@email_message).to have_to("to@example.org")
-            expect(@email_message).to have_cc("cc@example.org")
-            expect(@email_message).to have_bcc("bcc@example.org")
+          it 'does not alter normally sanitized attributes' do
+            expect(@email_message).to have_to('to@example.org')
+            expect(@email_message).to have_cc('cc@example.org')
+            expect(@email_message).to have_bcc('bcc@example.org')
             expect(@email_message).not_to have_header(
-              "X-Sanitize-Email-To",
-              "to@example.org"
+              'X-Sanitize-Email-To',
+              'to@example.org'
             )
             expect(@email_message).not_to have_header(
-              "X-Sanitize-Email-Cc",
-              "cc@example.org"
+              'X-Sanitize-Email-Cc',
+              'cc@example.org'
             )
             expect(@email_message).not_to have_header(
-              "X-Sanitize-Email-Bcc",
-              "bcc@example.org"
+              'X-Sanitize-Email-Bcc',
+              'bcc@example.org'
             )
           end
         end
@@ -618,331 +612,333 @@ describe SanitizeEmail do
     end
   end
 
-  context "config options" do
-    context ":use_actual_environment_prepended_to_subject" do
-      context "true" do
-        before(:each) do
+  context 'config options' do
+    context ':use_actual_environment_prepended_to_subject' do
+      context 'true' do
+        before do
           configure_sanitize_email(
-            environment: "{{serverABC}}",
-            use_actual_environment_prepended_to_subject: true
+            :environment => '{{serverABC}}',
+            :use_actual_environment_prepended_to_subject => true
           )
           sanitary_mail_delivery
         end
-        it "original to is prepended" do
+        it 'original to is prepended' do
           expect(@email_message).to have_subject(
-            "{{serverABC}} original subject"
+            '{{serverABC}} original subject'
           )
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
+        it 'does not prepend overrides' do
           expect(@email_message).not_to have_to_username(
-            "to at sanitize_email.org"
+            'to at sanitize_email.org'
           )
           expect(@email_message).not_to have_subject(
-            "(to at sanitize_email.org)"
+            '(to at sanitize_email.org)'
           )
         end
       end
-      context "false" do
-        before(:each) do
+      context 'false' do
+        before do
           configure_sanitize_email(
-            environment: "{{serverABC}}",
-            use_actual_environment_prepended_to_subject: false
+            :environment => '{{serverABC}}',
+            :use_actual_environment_prepended_to_subject => false
           )
           sanitary_mail_delivery
         end
-        it "original to is not prepended" do
+        it 'original to is not prepended' do
           expect(@email_message).not_to have_subject(
-            "{{serverABC}} original subject"
+            '{{serverABC}} original subject'
           )
-          expect(@email_message.subject).to eq("original subject")
+          expect(@email_message.subject).to eq('original subject')
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
+        it 'does not prepend overrides' do
           expect(@email_message).not_to have_to_username(
-            "to at sanitize_email.org"
+            'to at sanitize_email.org'
           )
           expect(@email_message).not_to have_subject(
-            "(to at sanitize_email.org)"
+            '(to at sanitize_email.org)'
           )
         end
       end
     end
 
-    context ":use_actual_email_prepended_to_subject" do
-      context "true" do
-        before(:each) do
-          configure_sanitize_email(use_actual_email_prepended_to_subject: true)
+    context ':use_actual_email_prepended_to_subject' do
+      context 'true' do
+        before do
+          configure_sanitize_email(:use_actual_email_prepended_to_subject => true)
         end
-        context "to address is an array" do
+        context 'to address is an array' do
           before do
             sanitary_mail_delivery_multiple_recipients
           end
-          it "original to is prepended" do
+          it 'original to is prepended' do
             expect(@email_message).to have_subject(
-              "(to1 at example.org,to2 at example.org,to3 at example.org) original subject"
+              '(to1 at example.org,to2 at example.org,to3 at example.org) original subject'
             )
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should not prepend overrides" do
+          it 'does not prepend overrides' do
             expect(@email_message).not_to have_to_username(
-              "to at sanitize_email.org"
+              'to at sanitize_email.org'
             )
             expect(@email_message).not_to have_subject(
-              "(to at sanitize_email.org)"
+              '(to at sanitize_email.org)'
             )
           end
         end
-        context "to address is not an array" do
+        context 'to address is not an array' do
           before do
             sanitary_mail_delivery
           end
-          it "original to is prepended" do
+          it 'original to is prepended' do
             expect(@email_message).to have_subject(
-              "(to at example.org) original subject"
+              '(to at example.org) original subject'
             )
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should not prepend overrides" do
+          it 'does not prepend overrides' do
             expect(@email_message).not_to have_to_username(
-              "to at sanitize_email.org"
+              'to at sanitize_email.org'
             )
             expect(@email_message).not_to have_subject(
-              "(to at sanitize_email.org)"
+              '(to at sanitize_email.org)'
             )
           end
         end
       end
-      context "false" do
-        before(:each) do
-          configure_sanitize_email(use_actual_email_prepended_to_subject: false)
+      context 'false' do
+        before do
+          configure_sanitize_email(:use_actual_email_prepended_to_subject => false)
           sanitary_mail_delivery
         end
-        it "original to is not prepended" do
+        it 'original to is not prepended' do
           expect(@email_message).not_to have_subject(
-            "(to at example.org) original subject"
+            '(to at example.org) original subject'
           )
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
+        it 'does not prepend overrides' do
           expect(@email_message).not_to have_to_username(
-            "to at sanitize_email.org"
+            'to at sanitize_email.org'
           )
           expect(@email_message).not_to have_subject(
-            "(to at sanitize_email.org)"
+            '(to at sanitize_email.org)'
           )
         end
       end
     end
 
-    context ":use_actual_email_as_sanitized_user_name" do
-      context "true" do
-        before(:each) do
+    context ':use_actual_email_as_sanitized_user_name' do
+      context 'true' do
+        before do
           configure_sanitize_email(
-            use_actual_email_as_sanitized_user_name: true
+            :use_actual_email_as_sanitized_user_name => true
           )
           sanitary_mail_delivery
         end
-        it "original to is munged and prepended" do
+        it 'original to is munged and prepended' do
           expect(@email_message).to have_to_username(
-            "to at example.org <to@sanitize_email.org>"
+            'to at example.org <to@sanitize_email.org>'
           )
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
+        it 'does not prepend overrides' do
           expect(@email_message).not_to have_to_username(
-            "to at sanitize_email.org"
+            'to at sanitize_email.org'
           )
           expect(@email_message).not_to have_subject(
-            "(to at sanitize_email.org)"
+            '(to at sanitize_email.org)'
           )
         end
       end
-      context "false" do
-        before(:each) do
+      context 'false' do
+        before do
           configure_sanitize_email(
-            use_actual_email_as_sanitized_user_name: false
+            :use_actual_email_as_sanitized_user_name => false
           )
           sanitary_mail_delivery
         end
-        it "original to is not prepended" do
+        it 'original to is not prepended' do
           expect(@email_message).not_to have_to_username(
-            "to at example.org <to@sanitize_email.org>"
+            'to at example.org <to@sanitize_email.org>'
           )
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
+        it 'does not prepend overrides' do
           expect(@email_message).not_to have_to_username(
-            "to at sanitize_email.org"
+            'to at sanitize_email.org'
           )
           expect(@email_message).not_to have_subject(
-            "(to at sanitize_email.org)"
+            '(to at sanitize_email.org)'
           )
         end
       end
     end
 
-    context ":engage" do
-      context "is true" do
-        before(:each) do
+    context ':engage' do
+      context 'is true' do
+        before do
           # Should turn off sanitization using the force_sanitize
           configure_sanitize_email(
-            engage: true,
-            sanitized_recipients: "marv@example.org",
-            use_actual_email_prepended_to_subject: true,
-            use_actual_email_as_sanitized_user_name: true
+            :engage => true,
+            :sanitized_recipients => 'marv@example.org',
+            :use_actual_email_prepended_to_subject => true,
+            :use_actual_email_as_sanitized_user_name => true
           )
           mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should prepend overrides" do
-          expect(@email_message).to have_to_username("to at example.org")
-          expect(@email_message).to have_subject("(to at example.org)")
+        it 'prepends overrides' do
+          expect(@email_message).to have_to_username('to at example.org')
+          expect(@email_message).to have_subject('(to at example.org)')
         end
-        it "should alter normally sanitized attributes" do
-          expect(@email_message).not_to have_to("to@example.org")
-          expect(@email_message).to have_to("marv@example.org")
+        it 'alters normally sanitized attributes' do
+          expect(@email_message).not_to have_to('to@example.org')
+          expect(@email_message).to have_to('marv@example.org')
         end
       end
-      context "is false" do
-        before(:each) do
+      context 'is false' do
+        before do
           # Should turn off sanitization using the force_sanitize
           configure_sanitize_email(
-            engage: false,
-            sanitized_recipients: "marv@example.org",
-            use_actual_email_prepended_to_subject: true,
-            use_actual_email_as_sanitized_user_name: true
+            :engage => false,
+            :sanitized_recipients => 'marv@example.org',
+            :use_actual_email_prepended_to_subject => true,
+            :use_actual_email_as_sanitized_user_name => true
           )
           mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not prepend overrides" do
-          expect(@email_message).not_to have_to_username("to at example.org")
-          expect(@email_message).not_to have_subject("(to at example.org)")
+        it 'does not prepend overrides' do
+          expect(@email_message).not_to have_to_username('to at example.org')
+          expect(@email_message).not_to have_subject('(to at example.org)')
         end
-        it "should not alter normally sanitized attributes" do
-          expect(@email_message).to have_to("to@example.org")
-          expect(@email_message).not_to have_to("marv@example.org")
+        it 'does not alter normally sanitized attributes' do
+          expect(@email_message).to have_to('to@example.org')
+          expect(@email_message).not_to have_to('marv@example.org')
         end
       end
     end
 
-    context "deprecated" do
-      #before(:each) do
+    context 'deprecated' do
+      # before(:each) do
       #  SanitizeEmail::Deprecation.deprecate_in_silence = false
-      #end
-      context ":local_environments" do
-        context "matching" do
-          before(:each) do
-            configure_sanitize_email(local_environments: ["test"])
-            expect(SanitizeEmail[:activation_proc].call).to eq(true)
+      # end
+      context ':local_environments' do
+        context 'matching' do
+          before do
+            configure_sanitize_email(:local_environments => ['test'])
             mail_delivery
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(described_class[:activation_proc].call).to eq(true)
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should use activation_proc for matching environment" do
-            expect(@email_message).to match_to("to@sanitize_email.org")
-            expect(@email_message).to match_cc("cc@sanitize_email.org")
-            expect(@email_message).to match_bcc("bcc@sanitize_email.org")
+          it 'uses activation_proc for matching environment' do
+            expect(described_class[:activation_proc].call).to eq(true)
+            expect(@email_message).to match_to('to@sanitize_email.org')
+            expect(@email_message).to match_cc('cc@sanitize_email.org')
+            expect(@email_message).to match_bcc('bcc@sanitize_email.org')
           end
         end
-        context "non-matching" do
-          before(:each) do
-            sanitize_spec_dryer("production")
+        context 'non-matching' do
+          before do
+            sanitize_spec_dryer('production')
             # Won't match!
-            configure_sanitize_email(local_environments: ["development"])
-            expect(SanitizeEmail[:activation_proc].call).to eq(false)
+            configure_sanitize_email(:local_environments => ['development'])
             mail_delivery
           end
-          it "should not alter non-sanitized attributes" do
-            expect(@email_message).to have_from("from@example.org")
-            expect(@email_message).to have_reply_to("reply_to@example.org")
-            expect(@email_message).to have_body_text("funky fresh")
+          it 'does not alter non-sanitized attributes' do
+            expect(described_class[:activation_proc].call).to eq(false)
+            expect(@email_message).to have_from('from@example.org')
+            expect(@email_message).to have_reply_to('reply_to@example.org')
+            expect(@email_message).to have_body_text('funky fresh')
           end
-          it "should use activation_proc for non-matching environment" do
-            expect(@email_message).to have_to("to@example.org")
-            expect(@email_message).to have_cc("cc@example.org")
-            expect(@email_message).to have_bcc("bcc@example.org")
+          it 'uses activation_proc for non-matching environment' do
+            expect(described_class[:activation_proc].call).to eq(false)
+            expect(@email_message).to have_to('to@example.org')
+            expect(@email_message).to have_cc('cc@example.org')
+            expect(@email_message).to have_bcc('bcc@example.org')
           end
         end
       end
 
-      context ":sanitized_recipients" do
-        before(:each) do
+      context ':sanitized_recipients' do
+        before do
           configure_sanitize_email(
-            sanitized_recipients: "barney@sanitize_email.org"
+            :sanitized_recipients => 'barney@sanitize_email.org'
           )
           sanitary_mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "used as sanitized_to" do
-          expect(@email_message).to have_to("barney@sanitize_email.org")
+        it 'used as sanitized_to' do
+          expect(@email_message).to have_to('barney@sanitize_email.org')
         end
       end
 
-      context ":force_sanitize" do
-        before(:each) do
+      context ':force_sanitize' do
+        before do
           # Should turn off sanitization using the force_sanitize
           configure_sanitize_email(
-            activation_proc: proc { true },
-            force_sanitize: false
+            :activation_proc => proc { true },
+            :force_sanitize => false
           )
           mail_delivery
         end
-        it "should not alter non-sanitized attributes" do
-          expect(@email_message).to have_from("from@example.org")
-          expect(@email_message).to have_reply_to("reply_to@example.org")
-          expect(@email_message).to have_body_text("funky fresh")
+        it 'does not alter non-sanitized attributes' do
+          expect(@email_message).to have_from('from@example.org')
+          expect(@email_message).to have_reply_to('reply_to@example.org')
+          expect(@email_message).to have_body_text('funky fresh')
         end
-        it "should not alter normally sanitized attributes" do
-          expect(@email_message).to have_to("to@example.org")
+        it 'does not alter normally sanitized attributes' do
+          expect(@email_message).to have_to('to@example.org')
         end
       end
     end
   end
 end
 
-#TODO: test good_list
+# TODO: test good_list