sanitize_email 2.0.0 → 2.0.1

data/lib/sanitize_email/bleach.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
@@ -9,30 +11,22 @@ module SanitizeEmail
     attr_accessor :overridden_addresses # TODO: Just a stub, not implemented
 
     def initialize(*args)
-      deprecation_message = <<EOS
-SanitizeEmail:
-  Passing arguments to SanitizeEmail::Bleach.new is deprecated.
-  SanitizeEmail::Bleach.new now takes no arguments.
-EOS
-      if !args.empty?
-        self.class.deprecation_warning_message(deprecation_message)
-      end
+      deprecation_message unless args.empty?
     end
 
     # If all recipient addresses are white-listed the field is left alone.
     def self.delivering_email(message)
-      if self.sanitize_engaged?(message)
-        SanitizeEmail::MailHeaderTools.
-          add_original_addresses_as_headers(message)
-        SanitizeEmail::MailHeaderTools.
-          prepend_custom_subject(message)
+      return nil unless sanitize_engaged?(message)
+      SanitizeEmail::MailHeaderTools.
+        add_original_addresses_as_headers(message)
+      SanitizeEmail::MailHeaderTools.
+        prepend_custom_subject(message)
 
-        overridden = SanitizeEmail::OverriddenAddresses.new(message)
+      overridden = SanitizeEmail::OverriddenAddresses.new(message)
 
-        message.to = overridden.overridden_to
-        message.cc = overridden.overridden_cc
-        message.bcc = overridden.overridden_bcc
-      end
+      message.to = overridden.overridden_to
+      message.cc = overridden.overridden_cc
+      message.bcc = overridden.overridden_bcc
     end
 
     # Will be called by the Hook to determine if an override should occur
@@ -76,7 +70,6 @@ EOS
     # If installed but not configured, sanitize_email DOES NOTHING.
     # Until configured the defaults leave it turned off.
     def self.sanitize_engaged?(message)
-
       # Don't sanitize the message if it will not be delivered
       return false unless message.perform_deliveries
 
@@ -89,11 +82,18 @@ EOS
       return engaged unless engaged.nil?
 
       # Should we sanitize due to the activation_proc?
-      return SanitizeEmail.activate?(message)
-
+      SanitizeEmail.activate?(message)
     end
 
-  end # end Class Bleach
-end # end Module SanitizeEmail
-
+  private
 
+    def deprecation_message
+      deprecation = <<~DEPRECATION
+        SanitizeEmail:
+          Passing arguments to SanitizeEmail::Bleach.new is deprecated.
+          SanitizeEmail::Bleach.new now takes no arguments.
+      DEPRECATION
+      self.class.deprecation_warning_message(deprecation)
+    end
+  end
+end

data/lib/sanitize_email/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
@@ -5,7 +7,6 @@ module SanitizeEmail
   # The API for configuring SanitizeEmail is via `SanitizeEmail.config`
   # Available configuration options are listed in the `DEFAULTS` constant.
   class Config
-
     extend SanitizeEmail::Deprecation
 
     class << self
@@ -34,9 +35,9 @@ module SanitizeEmail
       :bad_list => nil,
 
       :environment => if defined?(Rails) && Rails.env.present?
-                        ("[" << Rails.env << "]")
+                        "[#{Rails.env}]"
                       else
-                        "[UNKNOWN ENVIRONMENT]"
+                        '[UNKNOWN ENVIRONMENT]'
                       end,
 
       # Use the "real" email address as the username
@@ -56,20 +57,20 @@ module SanitizeEmail
       #   while nil ignores this setting and checks activation_proc
       :engage => nil,
 
-      :activation_proc => Proc.new { false }
-    }
+      :activation_proc => proc { false },
+    }.freeze
 
     @config ||= DEFAULTS.dup
-    def self.configure &block
+    def self.configure
       yield @config
 
       # Gracefully handle deprecated config values.
       # Actual deprecation warnings are thrown in the top SanitizeEmail module
       #   thanks to our use of dynamic methods.
       if @config[:local_environments] && defined?(Rails)
-        @config[:activation_proc] = Proc.new {
+        @config[:activation_proc] = proc do
           SanitizeEmail.local_environments.include?(Rails.env)
-        }
+        end
       end
       if @config[:sanitized_recipients]
         # calling it to trigger the deprecation warning.
@@ -78,17 +79,24 @@ module SanitizeEmail
         SanitizeEmail.sanitized_recipients
         @config[:sanitized_to] = @config[:sanitized_recipients]
       end
-      if !@config[:force_sanitize].nil?
-        deprecation_warning_message(
-            <<-EOS
+      config_force_sanitize_deprecation_warning
+    end
+
+    def self.config_force_sanitize_deprecation_warning
+      return nil if @config[:force_sanitize].nil?
+      deprecation_warning_message(
+        <<-DEPRECATION
               SanitizeEmail::Config.config[:force_sanitize] is deprecated.
               Please use SanitizeEmail.force_sanitize or SanitizeEmail.sanitary instead.
               Refer to https://github.com/pboling/sanitize_email/wiki for examples.
-            EOS
-        )
-        SanitizeEmail.force_sanitize = @config[:force_sanitize]
-      end
+      DEPRECATION
+      )
+      SanitizeEmail.force_sanitize = @config[:force_sanitize]
     end
 
+    INIT_KEYS = [:sanitized_to, :sanitized_cc, :sanitized_bcc, :good_list, :bad_list].freeze
+    def self.to_init
+      @config.select { |key, _value| INIT_KEYS.include?(key) }
+    end
   end
 end

data/lib/sanitize_email/deprecation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
@@ -5,7 +7,6 @@ module SanitizeEmail
   # Provides tools that allow methods to be deprecated with new releases of the gem.
   # See http://www.seejohncode.com/2012/01/09/deprecating-methods-in-ruby/
   module Deprecation
-
     class << self
       attr_accessor :deprecate_in_silence
     end
@@ -32,7 +33,7 @@ module SanitizeEmail
       alias_method old_name, name
       # And replace it with a wrapped version
       define_method(name) do |*args, &block|
-        self.deprecation(name, " (please use ##{replacement})")
+        deprecation(name, " (please use ##{replacement})")
         send old_name, *args, &block
       end
     end

data/lib/sanitize_email/engine.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.1
   class Engine < ::Rails::Engine
-
     config.to_prepare do
       ActionMailer::Base.register_interceptor(SanitizeEmail::Bleach)
     end
-
   end
 end

data/lib/sanitize_email/mail_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Cribbed from email_spec gem
 module SanitizeEmail::MailExt
   def default_part

data/lib/sanitize_email/mail_header_tools.rb

@@ -1,27 +1,28 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
 module SanitizeEmail
   # Tools for modifying the header of an email
   module MailHeaderTools
-
     def self.prepend_subject_array(message)
       prepend = []
       if SanitizeEmail.use_actual_email_prepended_to_subject
         prepend << SanitizeEmail::MailHeaderTools.
-          prepend_email_to_subject(Array(message.to))
+                   prepend_email_to_subject(Array(message.to))
       end
       if SanitizeEmail.use_actual_environment_prepended_to_subject
         prepend << SanitizeEmail::MailHeaderTools.
-          prepend_environment_to_subject
+                   prepend_environment_to_subject
       end
       # this will force later joins to add an extra space
-      prepend << "" unless prepend.empty?
+      prepend << '' unless prepend.empty?
       prepend
     end
 
     def self.custom_subject(message)
-      prepend_subject_array(message).join(" ")
+      prepend_subject_array(message).join(' ')
     end
 
     def self.prepend_environment_to_subject
@@ -39,38 +40,36 @@ module SanitizeEmail
       # See: http://goo.gl/v46GY
       {
         # can be an arrays, so casting it as arrays
-        "X-Sanitize-Email-To" => Array(message.to).uniq,
-        "X-Sanitize-Email-Cc" => Array(message.cc).uniq
+        'X-Sanitize-Email-To' => Array(message.to).uniq,
+        'X-Sanitize-Email-Cc' => Array(message.cc).uniq
         # Don't write out the BCC, as those addresses should not be visible
         #   in message headers for obvious reasons
-      }.each { |header_key, header_value|
+      }.each do |header_key, header_value|
         # For each type of address line
         SanitizeEmail::MailHeaderTools.update_header(
           header_key,
           header_value,
           message
         )
-      }
+      end
     end
 
     def self.prepend_custom_subject(message)
-      message.subject = "" unless message.subject
+      message.subject = '' unless message.subject
       custom_subject = SanitizeEmail::MailHeaderTools.custom_subject(message)
-      +(message.subject).prepend(custom_subject)
+      +message.subject.prepend(custom_subject)
     end
 
     # According to https://github.com/mikel/mail
     #   this is the correct way to update headers.
     def self.update_header(header_key, header_value, message)
+      return nil unless header_value
       # For each address, as header_value can be an array of addresses
-      Array(header_value).each_with_index { |elem, index|
+      Array(header_value).each_with_index do |elem, index|
         num = index + 1
-        new_header_key = num > 1 ?
-          "#{header_key}-#{num}" :
-          header_key
+        new_header_key = num > 1 ? "#{header_key}-#{num}" : header_key
         message.header[new_header_key] = elem.to_s
-      } if header_value
+      end
     end
-
   end
 end

data/lib/sanitize_email/overridden_addresses.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2008-16 Peter H. Boling of RailsBling.com
 # Released under the MIT license
 
 module SanitizeEmail
   # Tools for overriding addresses
   class OverriddenAddresses
-
     # Raised when after applying all sanitization rules there are no addresses to send the email to.
     class MissingTo < StandardError; end
 
@@ -13,126 +14,125 @@ module SanitizeEmail
     # recognized recipient types are: TO, CC, and BCC
     class UnknownOverride < StandardError; end
 
-    REPLACE_AT = [/@/, " at "]
-    REPLACE_ALLIGATOR = [/[<>]/, "~"]
+    REPLACE_AT = [/@/, ' at '].freeze
+    REPLACE_ALLIGATOR = [/[<>]/, '~'].freeze
     attr_accessor :overridden_to, :overridden_cc, :overridden_bcc,
                   :good_list, # White-listed addresses will not be molested as to, cc, or bcc
                   :bad_list, # Black-listed addresses will be removed from to, cc and bcc when sanitization is engaged
                   :sanitized_to, :sanitized_cc, :sanitized_bcc # Replace non-white-listed addresses with these sanitized addresses.
 
-    def initialize(message, args = {})
+    def initialize(message, **args)
       # Not using extract_options! because non-rails compatibility is a goal
-      @sanitized_to = args[:sanitized_to] || SanitizeEmail::Config.config[:sanitized_to]
-      @sanitized_cc = args[:sanitized_cc] || SanitizeEmail::Config.config[:sanitized_cc]
-      @sanitized_bcc = args[:sanitized_bcc] || SanitizeEmail::Config.config[:sanitized_bcc]
-      @good_list = args[:good_list] || SanitizeEmail::Config.config[:good_list] || []
-      @bad_list = args[:bad_list] || SanitizeEmail::Config.config[:bad_list] || []
-      @overridden_to = self.to_override(message.to)
-      @overridden_cc = self.cc_override(message.cc)
-      @overridden_bcc = self.bcc_override(message.bcc)
+      args = SanitizeEmail::Config.to_init.merge(args)
+      @sanitized_to = args[:sanitized_to]
+      @sanitized_cc = args[:sanitized_cc]
+      @sanitized_bcc = args[:sanitized_bcc]
+      @good_list = args[:good_list] || []
+      @bad_list = args[:bad_list] || []
+      @overridden_to = to_override(message.to)
+      @overridden_cc = cc_override(message.cc)
+      @overridden_bcc = bcc_override(message.bcc)
     end
 
     # Allow good listed email addresses, and then remove the bad listed addresses
     def good_listize(real_addresses)
-      good_listed = self.clean_addresses(real_addresses, :good_list)
-      good_listed = self.clean_addresses(good_listed, :bad_list) unless good_listed.empty?
+      good_listed = clean_addresses(real_addresses, :good_list)
+      good_listed = clean_addresses(good_listed, :bad_list) unless good_listed.empty?
       good_listed
     end
 
     def to_override(actual_addresses)
       to = override_email(:to, actual_addresses)
       raise MissingTo, "after overriding :to (#{actual_addresses}) there are no addresses to send in To: header." if to.empty?
-      to.join(",")
+      to.join(',')
     end
 
     def cc_override(actual_addresses)
-      override_email(:cc, actual_addresses).join(",")
+      override_email(:cc, actual_addresses).join(',')
     end
 
     def bcc_override(actual_addresses)
-      override_email(:bcc, actual_addresses).join(",")
+      override_email(:bcc, actual_addresses).join(',')
     end
 
     def override_email(type, actual_addresses)
       # Normalized to an arrays
-      #puts "override_email 1: #{type} - #{actual_addresses}"
+      # puts "override_email 1: #{type} - #{actual_addresses}"
       real_addresses = Array(actual_addresses)
 
-      #puts "override_email 2: #{type} - #{real_addresses}"
+      # puts "override_email 2: #{type} - #{real_addresses}"
       # If there were no original recipients, then we DO NOT override the nil with the sanitized recipients
       return [] if real_addresses.empty?
 
       good_listed = good_listize(real_addresses)
-      #puts "override_email 3: #{type} - #{good_listed}"
+      # puts "override_email 3: #{type} - #{good_listed}"
       # If there are good_list addresses to send to then use them as is, no mods needed
       return good_listed unless good_listed.empty?
 
       # TODO: Allow overriding if an addressed email is on the good list?
       # If there are no sanitized addresses we can't override!
       sanitized_addresses = sanitize_addresses(type)
-      #puts "override_email 4: #{type} - #{sanitized_addresses}"
+      # puts "override_email 4: #{type} - #{sanitized_addresses}"
       return [] if sanitized_addresses.empty?
 
       # At this point it is assured that the address list will need to be sanitized
       # One more check to ensure none of the configured sanitized email addresses are on the bad_list
-      sanitized_addresses = self.clean_addresses(sanitized_addresses, :bad_list)
-      #puts "override_email 5: #{type} - #{sanitized_addresses}"
+      sanitized_addresses = clean_addresses(sanitized_addresses, :bad_list)
+      # puts "override_email 5: #{type} - #{sanitized_addresses}"
 
       # If we don't want to inject the "email" in the "user name" section of the sanitized recipients,
       # then just return the default sanitized recipients
       return sanitized_addresses unless SanitizeEmail.use_actual_email_as_sanitized_user_name
 
-      with_user_names = self.inject_user_names(real_addresses, sanitized_addresses)
-      #puts "real_addresses 2: #{real_addresses}"
-      #puts "override_email 6: #{type} - #{with_user_names}"
+      with_user_names = inject_user_names(real_addresses, sanitized_addresses)
+      # puts "real_addresses 2: #{real_addresses}"
+      # puts "override_email 6: #{type} - #{with_user_names}"
       # Otherwise inject the email as the "user name"
-      return with_user_names
+      with_user_names
     end
 
     def address_list_filter(list_type, address)
       # TODO: How does this handle email addresses with user names like "Foo Example <foo@example.org>"
-      has_address = self.send(list_type).include?(address)
+      has_address = send(list_type).include?(address)
       case list_type
-        when :good_list then
-          has_address ? address : nil
-        when :bad_list then
-          has_address ? nil : address
+      when :good_list then
+        has_address ? address : nil
+      when :bad_list then
+        has_address ? nil : address
       end
     end
 
     def inject_user_names(real_addresses, sanitized_addresses)
-      real_addresses.inject([]) do |result, real_recipient|
-        if real_recipient.nil?
-          new_recipient = sanitized_addresses
-        else
-          #puts "SANITIZED: #{sanitized_addresses}"
-          new_recipient = sanitized_addresses.map { |sanitized| "#{real_recipient.gsub(REPLACE_AT[0], REPLACE_AT[1]).gsub(/[<>]/, '~')} <#{sanitized}>" }
-        end
+      real_addresses.each_with_object([]) do |real_recipient, result|
+        new_recipient = if real_recipient.nil?
+                          sanitized_addresses
+                        else
+                          # puts "SANITIZED: #{sanitized_addresses}"
+                          sanitized_addresses.map { |sanitized| "#{real_recipient.gsub(REPLACE_AT[0], REPLACE_AT[1]).gsub(/[<>]/, '~')} <#{sanitized}>" }
+                        end
         result << new_recipient
-        result
       end.flatten
     end
 
     def clean_addresses(addresses, list_type)
       # Normalize addresses just in case it isn't an array yet
-      addresses.map { |address|
+      addresses.map do |address|
         # If this address is on the good list then let it pass
-        self.address_list_filter(list_type, address)
-      }.compact.uniq
+        address_list_filter(list_type, address)
+      end.compact.uniq
     end
 
     def sanitize_addresses(type)
       case type
-        when :to then
-          Array(self.sanitized_to)
-        when :cc then
-          Array(self.sanitized_cc)
-        when :bcc then
-          Array(self.sanitized_bcc)
-        else
-          raise UnknownOverride, "unknown email override"
+      when :to then
+        Array(sanitized_to)
+      when :cc then
+        Array(sanitized_cc)
+      when :bcc then
+        Array(sanitized_bcc)
+      else
+        raise UnknownOverride, 'unknown email override'
       end
     end
-
   end
 end