Class: SanitizeEmail::OverriddenAddresses

Inherits:
Object
  • Object
show all
Defined in:
lib/sanitize_email/overridden_addresses.rb

Overview

Tools for overriding addresses

Defined Under Namespace

Classes: MissingTo, UnknownOverride

Constant Summary collapse

REPLACE_AT = 
[/@/, ' at '].freeze
REPLACE_ALLIGATOR = 
[/[<>]/, '~'].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(message, **args) ⇒ OverriddenAddresses

Returns a new instance of OverriddenAddresses.



24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 24

def initialize(message, **args)
  # Not using extract_options! because non-rails compatibility is a goal
  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

Instance Attribute Details

#bad_list ⇒ Object

Returns the value of attribute bad_list.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def bad_list
  @bad_list
end

#good_list ⇒ Object

Returns the value of attribute good_list.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def good_list
  @good_list
end

#overridden_bcc ⇒ Object

Returns the value of attribute overridden_bcc.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def overridden_bcc
  @overridden_bcc
end

#overridden_cc ⇒ Object

Returns the value of attribute overridden_cc.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def overridden_cc
  @overridden_cc
end

#overridden_to ⇒ Object

Returns the value of attribute overridden_to.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def overridden_to
  @overridden_to
end

#sanitized_bcc ⇒ Object

Returns the value of attribute sanitized_bcc.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def sanitized_bcc
  @sanitized_bcc
end

#sanitized_cc ⇒ Object

Returns the value of attribute sanitized_cc.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def sanitized_cc
  @sanitized_cc
end

#sanitized_to ⇒ Object

Returns the value of attribute sanitized_to.



19
20
21
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 19

def sanitized_to
  @sanitized_to
end

Instance Method Details

#address_list_filter(list_type, address) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 94

def address_list_filter(list_type, address)
  # TODO: How does this handle email addresses with user names like "Foo Example <[email protected]>"
  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
  end
end

#bcc_override(actual_addresses) ⇒ Object 



54
55
56
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 54

def bcc_override(actual_addresses)
  override_email(:bcc, actual_addresses).join(',')
end

#cc_override(actual_addresses) ⇒ Object 



50
51
52
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 50

def cc_override(actual_addresses)
  override_email(:cc, actual_addresses).join(',')
end

#clean_addresses(addresses, list_type) ⇒ Object 



117
118
119
120
121
122
123
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 117

def clean_addresses(addresses, list_type)
  # Normalize addresses just in case it isn't an array yet
  addresses.map do |address|
    # If this address is on the good list then let it pass
    address_list_filter(list_type, address)
  end.compact.uniq
end

#good_listize(real_addresses) ⇒ Object

Allow good listed email addresses, and then remove the bad listed addresses



38
39
40
41
42
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 38

def good_listize(real_addresses)
  good_listed = clean_addresses(real_addresses, :good_list)
  good_listed = clean_addresses(good_listed, :bad_list) unless good_listed.empty?
  good_listed
end

#inject_user_names(real_addresses, sanitized_addresses) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 105

def inject_user_names(real_addresses, sanitized_addresses)
  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
  end.flatten
end

#override_email(type, actual_addresses) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 58

def override_email(type, actual_addresses)
  # Normalized to an arrays
  # puts "override_email 1: #{type} - #{actual_addresses}"
  real_addresses = Array(actual_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}"
  # 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}"
  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 = 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 = 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"
  with_user_names
end

#sanitize_addresses(type) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 125

def sanitize_addresses(type)
  case type
  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

#to_override(actual_addresses) ⇒ Object

Raises:



44
45
46
47
48
 
# File 'lib/sanitize_email/overridden_addresses.rb', line 44

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(',')
end