sanitize_email 1.0.0.alpha2 → 1.0.0.rc1

data/CHANGELOG

@@ -1,6 +1,18 @@
-Version 1.0.0.alpha1
-- Implementing initial support for Rails >= 3.0 (new ActionMailer API)
+Version 1.0.0.rc1
+- Added a good_list and a bad_list (whitelist and blacklist)
+- Added Deprecation library
+- Refactored Sanitization module into Hook class
+- Renamed Hook Class to Bleach Class
+- Improve support for non-rails implementations
+- Deprecated local_environments in favor of local_environment_proc
+- Deprecated sanitized_recipients in favor of sanitized_to
+- More specs
+
+Version 1.0.0.alpha2
+- Complete refactor!  Implementing initial support for Rails >= 3.0 (new ActionMailer API)
   - Support for Rails <= 2.X remains in version 0.X.X releases.
+- NinthBit namespace is now SanitizeEmail namespace
+- Now has a first class Config class
 
 XXXXXXXXXXXXXXXXXXXXXXX Rail 3.0+ Only Form here on up! XXXXXXXXXXXXXXXXXXXXXXX
 

data/VERSION.yml

@@ -2,4 +2,4 @@
 :major: 1
 :minor: 0
 :patch: 0
-:build: alpha2
+:build: rc1

data/lib/sanitize_email.rb

@@ -4,18 +4,19 @@ require 'rails'
 require 'action_mailer'
 
 module SanitizeEmail
-  if defined?(Rails) && ::Rails::VERSION::MAJOR >= 3
-    require 'sanitize_email/version'
-    require 'sanitize_email/config'
-    require 'sanitize_email/sanitizer'
-    require 'sanitize_email/hook'
+  require 'sanitize_email/version'
+  require 'sanitize_email/config'
+  require 'sanitize_email/bleach'
+  require 'sanitize_email/deprecation'
 
+  # Allow non-rails implementations to use this gem
+  if @rails = defined?(Rails) && ::Rails::VERSION::MAJOR >= 3
     if ::Rails::VERSION::MINOR >= 1
       require 'sanitize_email/engine'
     elsif ::Rails::VERSION::MINOR == 0
       require 'sanitize_email/railtie'
     end
-  else
+  elsif @rails = defined?(Rails)
     raise "Please use the 0.X.X versions of sanitize_email for Rails 2.X and below."
   end
 
@@ -28,4 +29,17 @@ module SanitizeEmail
     SanitizeEmail[name]
   end
 
+  def self.sanitized_recipients
+    SanitizeEmail[:sanitized_recipients]
+  end
+
+  def self.local_environments
+    SanitizeEmail[:local_environments]
+  end
+
+  class << self
+    extend SanitizeEmail::Deprecation
+    deprecated_alias :sanitized_recipients, :sanitized_to
+    deprecated :local_environments, :local_environment_proc
+  end
 end

data/lib/sanitize_email/bleach.rb

@@ -0,0 +1,156 @@
+#Copyright (c) 2008-12 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module SanitizeEmail
+  class Bleach
+
+    class MissingTo < StandardError; end
+    class UnknownOverride < StandardError; end
+
+    # Can override global configs at the instance level.
+    attr_accessor :engage, # Turn sanitization on or off just for this instance
+      :sanitized_to, :sanitized_cc, :sanitized_bcc, # Replace non-white-listed addresses with these sanitized addresses.
+      :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
+      :injected  # Track whether or not the subject has been injected with usernames
+
+    def initialize(args = {})
+      # Not using extract_options! because no-rails compatibility is a goal
+      @sanitized_to = args[:sanitized_to]    || SanitizeEmail[:sanitized_to]
+      @sanitized_cc = args[:sanitized_cc]    || SanitizeEmail[:sanitized_cc]
+      @sanitized_bcc = args[:sanitized_bcc]  || SanitizeEmail[:sanitized_bcc]
+      @good_list = args[:good_list]          || SanitizeEmail[:good_list]     || []
+      @bad_list = args[:bad_list]            || SanitizeEmail[:bad_list]      || []
+      @engage = args[:engage]                || SanitizeEmail[:engage]
+      @injected = false
+    end
+
+    # If all recipient addresses are white-listed the field is left alone.
+    def delivering_email(message)
+      if self.sanitize_engaged?
+        message.subject = self.subject_override(message.subject, message.to) if SanitizeEmail.use_actual_email_prepended_to_subject
+        message.to = self.to_override(message.to)
+        message.cc = self.cc_override(message.cc)
+        message.bcc = self.bcc_override(message.bcc)
+      end
+    end
+
+    # Only relevant
+    def consider_local?
+      SanitizeEmail.local_environment_proc.call if SanitizeEmail.local_environment_proc.respond_to?(:call)
+    end
+
+    # This method will be called by the Hook to determine if an override should occur
+    def sanitize_engaged?
+      !SanitizeEmail.force_sanitize.nil? ? SanitizeEmail.force_sanitize : self.consider_local?
+    end
+
+    def subject_override(real_subject, actual_addresses)
+      if !actual_addresses.respond_to?(:join)
+        real_subject
+      else
+        "(#{actual_addresses.join(',').gsub(/@/,' at ').gsub(/[<>]/,'~')}) #{real_subject}"
+      end
+    end
+
+    def to_override(actual_addresses)
+      to = override_email(:to, actual_addresses)
+      raise MissingTo, 'after overriding :to there are no addresses to send in To: header.' if to.empty?
+      to.join(',')
+    end
+
+    def cc_override(actual_addresses)
+      override_email(:cc, actual_addresses).join(',')
+    end
+
+    def bcc_override(actual_addresses)
+      override_email(:bcc, actual_addresses).join(',')
+    end
+
+    #######
+    protected
+    #######
+
+    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)
+      case list_type
+        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
+          new_recipient = sanitized_addresses.map{|sanitized| "#{real_recipient.gsub(/@/,' at ').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|
+        # If this address is on the good list then let it pass
+        self.address_list_filter(list_type, address)
+      }.compact
+    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"
+      end
+    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
+    end
+
+    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?
+
+      # If there are no sanitized addresses we can't override!
+      sanitized_addresses = sanitize_addresses(type)
+#puts "override_email 3: #{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 4: #{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 "override_email 5: #{type} - #{with_user_names}"
+      # Otherwise inject the email as the 'user name'
+      return with_user_names
+    end
+
+  end # end Class Hook
+end # end Module SanitizeEmail
+
+

data/lib/sanitize_email/config.rb

@@ -13,7 +13,13 @@ module SanitizeEmail
 
       # The recipient addresses for the messages, either as a string (for a single
       # address) or an array (for multiple addresses) that go out in 'local' environments
-      :sanitized_recipients => nil,
+      :sanitized_to => nil,
+
+      # a white list
+      :good_list => nil,
+
+      # a black list
+      :bad_list => nil,
 
       # Use the 'real' email address as the username for the sanitized email address
       # e.g. "real@example.com <sanitized@example.com>"
@@ -23,11 +29,20 @@ module SanitizeEmail
       # e.g. "real@example.com rest of subject"
       :use_actual_email_prepended_to_subject => false,
 
-      :local_environments => %w( development test )
+      :local_environment_proc => Proc.new { true }
     }
 
     def self.configure &block
       yield self.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[:local_environment_proc] = Proc.new { SanitizeEmail.local_environments.include?(Rails.env) }
+      end
+      if config[:sanitize_recipients]
+        config[:sanitize_to] = SanitizeEmail.sanitized_recipients
+      end
     end
 
   end

data/lib/sanitize_email/deprecation.rb

@@ -0,0 +1,36 @@
+# See http://www.seejohncode.com/2012/01/09/deprecating-methods-in-ruby/
+
+module SanitizeEmail
+  module Deprecation
+
+    # Define a deprecated alias for a method
+    # @param [Symbol] name - name of method to define
+    # @param [Symbol] replacement - name of method to (alias)
+    def deprecated_alias(name, replacement)
+      # Create a wrapped version
+      define_method(name) do |*args, &block|
+        warn "SanitizeEmail: ##{name} deprecated (please use ##{replacement})"
+        send replacement, *args, &block
+      end
+    end
+
+    # Deprecate a defined method
+    # @param [Symbol] name - name of deprecated method
+    # @param [Symbol] replacement - name of the desired replacement
+    def deprecated(name, replacement = nil)
+      # Replace old method
+      old_name = :"#{name}_without_deprecation"
+      alias_method old_name, name
+      # And replace it with a wrapped version
+      define_method(name) do |*args, &block|
+        if replacement
+          warn "SanitizeEmail: ##{name} deprecated (please use ##{replacement})"
+        else
+          warn "SanitizeEmail: ##{name} deprecated"
+        end
+        send old_name, *args, &block
+      end
+    end
+
+  end
+end

data/lib/sanitize_email/engine.rb

@@ -5,7 +5,7 @@ module SanitizeEmail
   class Engine < ::Rails::Engine
 
     config.to_prepare do
-      ActionMailer::Base.register_interceptor(SanitizeEmail::Hook)
+      ActionMailer::Base.register_interceptor(SanitizeEmail::Bleach)
     end
 
   end

data/lib/sanitize_email/railtie.rb

@@ -5,7 +5,7 @@ module SanitizeEmail
   class Railtie < ::Rails::Railtie
 
     config.before_configuration do
-      ActionMailer::Base.register_interceptor(SanitizeEmail::Hook)
+      ActionMailer::Base.register_interceptor(SanitizeEmail::Bleach)
     end
 
   end

data/lib/sanitize_email/version.rb

@@ -1,5 +1,5 @@
 #Copyright (c) 2008-12 Peter H. Boling of 9thBit LLC
 #Released under the MIT license
 module SanitizeEmail
-  VERSION = '1.0.0.alpha2'
+  VERSION = '1.0.0.rc1'
 end

data/sanitize_email.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "sanitize_email"
-  s.version = "1.0.0.alpha2"
+  s.version = "1.0.0.rc1"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Peter Boling", "John Trupiano", "George Anderson"]
-  s.date = "2012-07-28"
+  s.date = "2012-08-04"
   s.description = "Tool to aid in development, testing, qa, and production troubleshooting of email issues without worrying that emails will get sent to actual live addresses."
   s.email = ["peter.boling@gmail.com", "jtrupiano@gmail.com", "george@benevolentcode.com"]
   s.extra_rdoc_files = [
@@ -26,16 +26,15 @@ Gem::Specification.new do |s|
     "VERSION.yml",
     "init.rb",
     "lib/sanitize_email.rb",
+    "lib/sanitize_email/bleach.rb",
     "lib/sanitize_email/config.rb",
+    "lib/sanitize_email/deprecation.rb",
     "lib/sanitize_email/engine.rb",
-    "lib/sanitize_email/hook.rb",
     "lib/sanitize_email/railtie.rb",
-    "lib/sanitize_email/sanitizer.rb",
     "lib/sanitize_email/version.rb",
     "sanitize_email.gemspec",
     "spec/sanitize_email_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/tmp/mail_dump/1343461037_3f3edd7/plain.html"
+    "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/pboling/sanitize_email"
   s.licenses = ["MIT"]

data/spec/sanitize_email_spec.rb

@@ -1,68 +1,136 @@
 require 'spec_helper'
 
+#
+# TODO: Letter Opener should *not* be required, but setting the delivery method to :file was causing connection errors... WTF?
+#
+# Letter Opener won't let us test the to when the to has a 'user name'
+#   @email_file.should have_to("~to at example.org~ <to@sanitize_email.org>")
+# TODO: Also not sure how to test the user name part of the To: header via the mail object
+#
+# Letter Opener won't let us test the bcc
+#   @email_file.should have_cc("cc@sanitize_email.org")
+# Fortunately we can still test the mail object returned by the deliver call
+#
+
 describe SanitizeEmail do
 
-  SanitizeEmail::Config.configure do |config|
-    config[:sanitized_recipients] = 'to@sanitize_email.org'
-    config[:sanitized_bcc] =        'bcc@sanitize_email.org'
-    config[:sanitized_cc] =         'cc@sanitize_email.org'
-    config[:local_environments] =   []
-    config[:use_actual_email_prepended_to_subject] = true
-    config[:use_actual_email_as_sanitized_user_name] = true
+  after(:each) do
+    SanitizeEmail::Config.config = {}
+  end
+
+  def sanitize_spec_dryer(rails_env = 'test')
+    Launchy.stub(:open)
+    location = File.expand_path('../tmp/mail_dump', __FILE__)
+    FileUtils.rm_rf(location)
+    Mail.defaults do
+      delivery_method LetterOpener::DeliveryMethod, :location => location
+    end
+    Rails.stub(:env).and_return(rails_env)
+    @location = location
+  end
+
+  def configure_sanitize_email(sanitize_hash = {})
+    sanitize_hash.reverse_merge!({
+      :sanitized_to =>  'to@sanitize_email.org',
+      :sanitized_cc =>  'cc@sanitize_email.org',
+      :sanitized_bcc => 'bcc@sanitize_email.org',
+      :use_actual_email_prepended_to_subject => true,
+      :use_actual_email_as_sanitized_user_name => true
+    })
+    SanitizeEmail::Config.configure do |config|
+      config[:sanitized_to] =         sanitize_hash[:sanitized_to]
+      config[:sanitized_cc] =         sanitize_hash[:sanitized_cc]
+      config[:sanitized_bcc] =        sanitize_hash[:sanitized_bcc]
+      config[:use_actual_email_prepended_to_subject] = sanitize_hash[:use_actual_email_prepended_to_subject]
+      config[:use_actual_email_as_sanitized_user_name] = sanitize_hash[:use_actual_email_as_sanitized_user_name]
+      # For testing deprecated configuration options:
+      config[:local_environments] =   sanitize_hash[:local_environments] if sanitize_hash[:local_environments]
+      config[:sanitized_to] ||= sanitize_hash[:sanitized_recipients] if sanitize_hash[:sanitized_recipients]
+    end
+    Mail.register_interceptor(SanitizeEmail::Bleach.new)
   end
 
-  def sanitize_mail_delivery(sanitization_switch = false)
-    # Ensure that localish? will returns sanitization_switch
+  def sanitized_mail_delivery(sanitization_switch = false)
+    # Ensure that localish? will return sanitization_switch if true or false, and use proc when nil
     SanitizeEmail::Config.config[:force_sanitize] = sanitization_switch
     Launchy.should_receive(:open)
-    mail = Mail.deliver do
+    @mail_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'
     end
+    # All the email gets dumped to file once for each type of recipient (:to, :cc, :bcc)
+    # Each file is identical, so we only need to check one of them:
+    @email_file = File.read(Dir["#{@location}/*/plain.html"].first)
   end
 
-  before(:each) do
-    Launchy.stub(:open)
-    location = File.expand_path('../tmp/mail_dump', __FILE__)
-    FileUtils.rm_rf(location)
-    Mail.defaults do
-      delivery_method LetterOpener::DeliveryMethod, :location => location
+  context "localish?" do
+    before(:each) do
+      sanitize_spec_dryer
+      configure_sanitize_email
     end
-    Mail.register_interceptor(SanitizeEmail::Hook)
-    @location = location
-  end
 
-  context "localish? is false" do
-    it "alters nothing" do
-      sanitize_mail_delivery(false)
-      # All the email gets dumped to file once for each type of recipient (:to, :cc, :bcc)
-      # Each file is identical, so we only need to check one of them:
-      email = File.read(Dir["#{@location}/*/plain.html"].first)
-      email.should have_from("from@example.org")
-      email.should have_to("to@example.org")
-      # Letter Opener won't let us test the cc
-      #email.should have_cc("cc@example.org")
-      # Letter Opener won't let us test the bcc
-      #email.should have_bcc("cc@example.org")
-      email.should have_subject("original subject")
+    context "false" do
+      it "alters nothing" do
+        sanitized_mail_delivery(false)
+        @email_file.should have_from("from@example.org")
+        @email_file.should have_to("to@example.org")
+        @mail_message.header.fields[3].value.should_not have_to("to at example.org")
+        @mail_message.should have_cc("cc@example.org")
+        @mail_message.should have_bcc("bcc@example.org")
+        @email_file.should have_subject("original subject")
+      end
+    end
+
+    context "true" do
+      it "should override" do
+        sanitized_mail_delivery(true)
+        @email_file.should have_from("from@example.org")
+        #puts "@mail_message.header.fields[3]: #{@mail_message.header.fields[3]}"
+        #@mail_message.header.fields[3].value.should have_to("to at example.org")
+        @mail_message.should have_cc("cc@sanitize_email.org")
+        @mail_message.should have_bcc("bcc@sanitize_email.org")
+        @email_file.should have_subject("(to at example.org) original subject")
+      end
     end
   end
 
-  context "localish? is true" do
-    it "should override" do
-      sanitize_mail_delivery(true)
-      # All the email gets dumped to file once for each type of recipient (:to, :cc, :bcc)
-      # Each file is identical, so we only need to check one of them:
-      email = File.read(Dir["#{@location}/*/plain.html"].first)
-      email.should have_from("from@example.org")
-      # Letter Opener won't let us test the to when the to has a 'user name'
-      #email.should have_to("~to at example.org~ <to@sanitize_email.org>")
-      # Letter Opener won't let us test the bcc
-      #email.should have_cc("cc@sanitize_email.org")
-      email.should have_subject("(to at example.org) original subject")
+  context "deprecated config options" do
+    context "local_environments" do
+      it "should use local_environment_proc for matching environment" do
+        sanitize_spec_dryer('test')
+        configure_sanitize_email({:local_environments => ['test']})
+        SanitizeEmail[:local_environment_proc].call.should == true
+        sanitized_mail_delivery(nil)
+        @email_file.should have_to("to@sanitize_email.org")
+        @email_file.should have_subject("(to at example.org) original subject")
+      end
+      it "should use local_environment_proc for non-matching environment" do
+        sanitize_spec_dryer('production')
+        configure_sanitize_email({:local_environments => ['development']}) # Won't match!
+        SanitizeEmail[:local_environment_proc].call.should == false
+        sanitized_mail_delivery(nil)
+        @mail_message.should_not have_subject("to at example.org")
+      end
+    end
+
+    context "sanitized_recipients is set" do
+      before(:each) do
+        sanitize_spec_dryer
+        configure_sanitize_email({:sanitized_recipients => 'barney@sanitize_email.org'})
+      end
+      it "used as sanitized_to" do
+        sanitized_mail_delivery(true)
+        @email_file.should have_from("from@example.org")
+        @mail_message.should have_to("to@sanitize_email.org")
+        @email_file.should have_subject("(to at example.org) original subject")
+      end
     end
   end
+
 end
+
+#TODO: test good_list

data/spec/spec_helper.rb

@@ -11,30 +11,61 @@ RSpec.configure do |config|
   #config.filter_run :focus
 end
 
+module EmailMatcherHelpers
+  class UnexpectedMailType < StandardError; end
+
+  # Sweet, nourishing recursion
+  def email_matching(matcher, part, mail_or_part)
+    if mail_or_part.respond_to?(part)
+      email_matching(matcher, part, mail_or_part.send(part))
+    elsif mail_or_part.respond_to?(:join)
+      email_matching(matcher, part, mail_or_part.join(', '))
+    elsif mail_or_part.respond_to?(:=~) # Can we match a regex against it?
+      mail_or_part =~ Regexp.new(Regexp.escape(matcher))
+    else
+      raise UnexpectedMailType, "Cannot match #{matcher} for #{part}"
+    end
+  end
+
+end
+
 RSpec::Matchers.define :have_from do |from|
+  include EmailMatcherHelpers
   match do |container|
-    container =~ Regexp.new(Regexp.escape(from))
+    email_matching(from, :from, container)
   end
 end
 RSpec::Matchers.define :have_to do |to|
+  include EmailMatcherHelpers
   match do |container|
-    container =~ Regexp.new(Regexp.escape(to))
+    email_matching(to, :to, container)
   end
 end
 RSpec::Matchers.define :have_cc do |cc|
+  include EmailMatcherHelpers
   match do |container|
-    container =~ Regexp.new(Regexp.escape(cc))
+    email_matching(cc, :cc, container)
   end
 end
 # The ActionMailer :file delivery method never prints bcc recipients...
-#   so not testable as such, but with letter_opener we can work magic
+# Neither does LetterOpener :(
+# But the mail object itself can be tested!
 RSpec::Matchers.define :have_bcc do |bcc|
+  include EmailMatcherHelpers
   match do |container|
-    container =~ Regexp.new(Regexp.escape(bcc))
+    email_matching(bcc, :bcc, container)
   end
 end
 RSpec::Matchers.define :have_subject do |subject|
+  include EmailMatcherHelpers
   match do |container|
-    container =~ Regexp.new(Regexp.escape(subject))
+    email_matching(subject, :subject, container)
   end
 end
+
+#RSpec::Matchers.define :have_to_username do |to|
+#  include EmailMatcherHelpers
+#  match do |container|
+#    email_matching(to, :, container)
+#  end
+#end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sanitize_email
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha2
+  version: 1.0.0.rc1
   prerelease: 6
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-28 00:00:00.000000000 Z
+date: 2012-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -194,16 +194,15 @@ files:
 - VERSION.yml
 - init.rb
 - lib/sanitize_email.rb
+- lib/sanitize_email/bleach.rb
 - lib/sanitize_email/config.rb
+- lib/sanitize_email/deprecation.rb
 - lib/sanitize_email/engine.rb
-- lib/sanitize_email/hook.rb
 - lib/sanitize_email/railtie.rb
-- lib/sanitize_email/sanitizer.rb
 - lib/sanitize_email/version.rb
 - sanitize_email.gemspec
 - spec/sanitize_email_spec.rb
 - spec/spec_helper.rb
-- spec/tmp/mail_dump/1343461037_3f3edd7/plain.html
 homepage: http://github.com/pboling/sanitize_email
 licenses:
 - MIT
@@ -219,7 +218,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3597304773529474340
+      hash: -2863798588423167662
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/sanitize_email/hook.rb

@@ -1,30 +0,0 @@
-#Copyright (c) 2008-12 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SanitizeEmail
-  class Hook
-
-    include SanitizeEmail::Sanitizer
-
-    def self.delivering_email(message)
-      if self.localish?
-        message.subject = self.subject_override(message.subject, message.to)
-        message.to = self.recipients_override(message.to)
-        message.cc = self.cc_override(message.cc)
-        message.bcc = self.bcc_override(message.bcc)
-      end
-    end
-
-    def self.consider_local?
-      SanitizeEmail.local_environments.include?(Rails.env) if defined?(Rails)
-    end
-
-    # This method will be called by the Hook to determine if an override should occur
-    def self.localish?
-      !SanitizeEmail.force_sanitize.nil? ? SanitizeEmail.force_sanitize : self.consider_local?
-    end
-
-  end # end Class Hook
-end # end Module SanitizeEmail
-
-

data/lib/sanitize_email/sanitizer.rb

@@ -1,73 +0,0 @@
-#Copyright (c) 2008-12 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-module SanitizeEmail
-  module Sanitizer
-    def self.included(base)
-      base.extend SanitizeEmail::Sanitizer::ClassMethods
-    end
-
-    module ClassMethods
-
-      def subject_override(real_subject, actual_addresses)
-        if actual_addresses.nil? || !SanitizeEmail.use_actual_email_prepended_to_subject
-          real_subject
-        else
-          "(#{actual_addresses.join(',').gsub(/@/,' at ').gsub(/[<>]/,'~')}) #{real_subject}"
-        end
-      end
-
-      def recipients_override(actual_addresses)
-        override_email(:recipients, actual_addresses)
-      end
-
-      def cc_override(actual_addresses)
-        override_email(:cc, actual_addresses)
-      end
-
-      def bcc_override(actual_addresses)
-        override_email(:bcc, actual_addresses)
-      end
-
-      #######
-      private
-      #######
-
-      def override_email(type, actual_addresses)
-        real_addresses, sanitized_addresses = case type
-          when :recipients
-            [actual_addresses, SanitizeEmail.sanitized_recipients]
-          when :cc
-            [actual_addresses, SanitizeEmail.sanitized_cc]
-          when :bcc
-            [actual_addresses, SanitizeEmail.sanitized_bcc]
-          else raise "sanitize_email error: unknown email override"
-        end
-        # Normalize to an array
-        real_addresses = [real_addresses] unless real_addresses.is_a?(Array)
-        # Normalize to an array
-        sanitized_addresses = [sanitized_addresses] unless sanitized_addresses.is_a?(Array)
-
-        # If there were no original recipients, then we DO NOT override the nil with the sanitized recipients
-        return nil if real_addresses.blank?
-        # If there are no sanitized addresses we can't override!
-        return nil if sanitized_addresses.blank?
-        # If we don't want to inject the actual 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
-
-        out = real_addresses.inject([]) do |result, real_recipient|
-          if real_recipient.nil?
-            new_recipient = sanitized_addresses
-          else
-            new_recipient = sanitized_addresses.map{|sanitized| "#{real_recipient.gsub(/@/,' at ').gsub(/[<>]/,'~')} <#{sanitized}>"}
-          end
-          result << new_recipient
-          result
-        end.flatten
-        return out
-      end
-
-    end
-
-  end
-end

data/spec/tmp/mail_dump/1343461037_3f3edd7/plain.html

@@ -1,76 +0,0 @@
-<style type="text/css">
-  #message_headers {
-    position: absolute;
-    top: 0px;
-    left: 0;
-    width: 100%;
-    height: 85px;
-    padding: 10px 0 0 0;
-    margin: 0;
-    background: #fff;
-    font-size: 12px;
-    font-family: "Lucida Grande";
-    border-bottom: 1px solid #dedede;
-    overflow: hidden;
-  }
-
-  #message_headers dl {
-    margin: 0;
-    padding: 0;
-  }
-
-  #message_headers dt {
-    width: 60px;
-    padding: 1px;
-    float: left;
-    text-align: right;
-    font-weight: bold;
-    color: #7f7f7f;
-  }
-
-  #message_headers dd {
-    margin-left: 70px;
-    padding: 1px;
-  }
-
-  #message_headers p.alternate {
-    position: absolute;
-    top: 0;
-    right: 15px;
-  }
-
-  #message_headers p.alternate a {
-    color: #09c;
-  }
-
-  pre#message_body {
-    padding: 10px;
-    word-wrap: break-word;
-  }
-
-  body {
-    margin-top: 96px;
-  }
-</style>
-
-<div id="message_headers">
-  <dl>
-    <dt>From:</dt>
-    <dd>from@example.org</dd>
-
-    <dt>Subject:</dt>
-    <dd><strong>(to at example.org) original subject</strong></dd>
-
-    <dt>Date:</dt>
-    <dd>Jul 28, 2012 03:37:17 AM EDT</dd>
-
-    <dt>To:</dt>
-    <dd>to@sanitize_email.org</dd>
-  </dl>
-
-  
-</div>
-
-
-  <pre id="message_body"></pre>
-