george-sanitize_email 0.2.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Peter H. Boling of 9thBit LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,116 @@
+= sanitize_email
+
+This gem allows you to globally override your mail delivery settings.  It's particularly helpful when you want to omit the delivery of email (e.g. in development/test environments) or alter the to/cc/bcc (e.g. in staging or demo environments) of all email generated from your application.
+
+It is a "configure it and forget it" type gem that requires very little setup.  It includes some very innocuous monkey patching of ActionMailer::Base to work its magic.
+
+Peter Boling wrote the plugin that this gem is derived from.  It currently solves three common problems in ruby web applications that use ActionMailer:
+
+=== Working Locally with Production Data
+
+Peter described this common problem in his original plugin implementation as such:
+
+# I have a production site with live data.
+# I dump the live data and securely transfer it to another machine (rync -e ssh), and import it using scripts that I will soon open source to.
+# On this separate machine (staging, or development) I run tests, and test various features.
+# I usually want the emails to get sent from these non-production environments so I can verify what they look like when sent, but I don't ever want to risk them getting sent to addresses that are not mine.
+
+=== Re-routing Email on a Staging or QA Server
+
+Another very important use case for me is to transparently re-route email generated from a staging or QA server to an appropriate person.  For example, it's common for us to set up a staging server for a client to use to view our progress and test out new features.  It's important for any email that is generated from our web application be delivered to the client's inbox so that they can review the content and ensure that it's acceptable.  Similarly, we set up QA instances for our own QA team and we use rails-caddy to allow each QA person to configure it specifically for them.
+
+=== Testing Email from a Hot Production Server
+
+If you install this gem on a production server (which I don't always do), you can load up script/console and override the to/cc/bcc on all emails for the duration of your console session.  This allows you to poke and prod a live production instance, and route all email to your own inbox for inspection.  The best part is that this can all be accomplished without changing a single line of your application code.
+
+== Install
+
+  gem sources -a http://gems.github.com/
+  gem install jtrupiano-sanitize_email
+
+== Setup
+
+It only requires a few lines of configuration:
+
+* Rails 1.x: Add to bottom of environment.rb
+		
+* Rails 2.x: Use an initializer, stick it in any initializer file, or create a new one for sanitize_email
+		
+Add this bit and customize for your app:
+
+<pre>
+  # Settings for sanitize_email gem.  These can be overridden in individual config/%env%/environment.rb files.
+
+  require 'sanitize_email'
+  ActionMailer::Base.sanitized_recipients = "jtrupiano@gmail.com"
+  ActionMailer::Base.sanitized_bcc = nil
+  ActionMailer::Base.sanitized_cc = nil
+  
+  # optionally, you can configure sanitize_email to to include the "real" email address as the 'user name' of the
+  # "sanitized" email (e.g. "real@address.com <sanitized@email.com>")
+  ActionMailer::Base.use_actual_email_as_sanitized_user_name = true # defaults to false
+
+  # These are the environments whose outgoing email BCC, CC and recipients fields will be overridden!  
+  # All environments not listed will be treated as normal.
+  ActionMailer::Base.local_environments = %w( development test staging )
+</pre>
+
+Keep in mind, this is ruby (and possibly rails), so you can add conditionals or utilize different environment.rb files to customize these settings on a per-environment basis.
+
+But wait there's more:
+
+Let's say you have a method in your model that you can call to test the signup email.
+You want to be able to test sending it to any user at any time... but you don't want
+the user to ACTUALLY get the email, even in production. A dilemma, yes?  Not anymore!
+
+All your mailers get a force_sanitize class method which takes precedence over the environment override.
+
+When force_sanitize is nil it will not be used by sanitize_email to determine if it should override the recipients, bcc, and cc.
+
+
+== Example
+
+So here's how you can use force_sanitize to override the override.
+
+Even if you set:
+
+  ActionMailer::Base.local_environments = %w( development )
+
+and are in the development environment, you can override the override anywhere in your code.
+
+<pre>
+  class User < ActiveRecord::Base
+    def test_signup_email_me_only
+      UserMailer.force_sanitize = true
+      UserMailer.deliver_signup_notification(self)
+      UserMailer.force_sanitize = nil
+    end
+
+    def test_signup_email_user_only
+      UserMailer.force_sanitize = false
+      UserMailer.deliver_signup_notification(self)
+      UserMailer.force_sanitize = nil
+    end
+
+    # this third method would conditionally use the overridden recipients based on current Rails environment
+    def test_signup_email_environment
+      UserMailer.deliver_signup_notification(self)
+    end
+
+  end
+</pre>
+
+Load the console with ruby script/console and regardless of what environment you are in:
+
+	> User.find(4).test_signup_email_me_only
+	
+and the email will have it's recipients, bcc, and cc overridden to be whatever you set the sanitized values to be.
+Then if you want to send it to the actual user, instead of yourself
+
+	> User.find(4).test_signup_email_user_only
+
+That's it!  Enjoy!
+
+Copyright (c) 2009 John Trupiano of SmartLogic Solutions, LLC
+Copyright (c) 2008 Peter H. Boling of 9thBit LLC
+Released under the MIT license

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "sanitize_email"
+    #s.executables = "jeweler"
+    s.summary = "Gemified fork of pboling's sanitize_email plugin: allows you to play with your application's email abilities without worrying that emails will get sent to actual live addresses."
+    s.email = "jtrupiano@gmail.com"
+    s.homepage = "http://github.com/jtrupiano/sanitize_email"
+    s.description = "allows you to play with your application's email abilities without worrying that emails will get sent to actual live addresses"
+    s.authors = ["John Trupiano", "Peter Boling"]
+    #s.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+    #s.add_dependency 'schacon-git'
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the sanitize_email plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the sanitize_email plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SanitizeEmail'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

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

data/lib/sanitize_email.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), "sanitize_email", "sanitize_email")
+require File.join(File.dirname(__FILE__), "sanitize_email", "custom_environments")
+
+ActionMailer::Base.send :include, NinthBit::CustomEnvironments
+ActionMailer::Base.send :include, NinthBit::SanitizeEmail

data/lib/sanitize_email/custom_environments.rb

@@ -0,0 +1,27 @@
+#Copyright (c) 2008 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module NinthBit
+  module CustomEnvironments
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+  
+      base.cattr_accessor :local_environments
+      base.local_environments = %w( development test )
+      
+      base.cattr_accessor :deployed_environments
+      base.deployed_environments = %w( production staging )
+    end
+
+    module ClassMethods
+      def consider_local?
+        local_environments.include?(ENV['RAILS_ENV'])
+      end
+      def consider_deployed?
+        deployed_environments.include?(ENV['RAILS_ENV'])
+      end
+    end
+    
+  end
+end

data/lib/sanitize_email/sanitize_email.rb

@@ -0,0 +1,87 @@
+#Copyright (c) 2008 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module NinthBit
+  module SanitizeEmail
+
+    def self.included(base)
+  
+      # Adds the following class attributes to the classes that include NinthBit::SanitizeEmail
+      base.cattr_accessor :force_sanitize
+      base.force_sanitize = nil
+      
+      # Specify the BCC addresses for the messages that go out in 'local' environments
+      base.cattr_accessor :sanitized_bcc
+      base.sanitized_bcc = nil
+     
+      # Specify the CC addresses for the messages that go out in 'local' environments
+      base.cattr_accessor :sanitized_cc
+      base.sanitized_cc = nil
+    
+      # 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
+      base.cattr_accessor :sanitized_recipients
+      base.sanitized_recipients = nil
+      
+      # Use the 'real' email address as the username for the sanitized email address
+      # e.g. "real@email.com <sanitized@email.com>"
+      base.cattr_accessor :use_actual_email_as_sanitized_user_name
+      base.use_actual_email_as_sanitized_user_name = false
+      
+      base.class_eval do
+        # We need to alias these methods so that our new methods get used instead
+        alias :real_bcc :bcc
+        alias :real_cc :cc
+        alias :real_recipients :recipients
+
+        def localish?
+          # consider_local is a method in sanitize_email/lib/custom_environments.rb
+          # it is included in ActionMailer in sanitize_email/init.rb
+          !self.class.force_sanitize.nil? ? self.class.force_sanitize : self.class.consider_local?
+        end
+
+        def recipients(*addresses)
+          real_recipients *addresses
+          puts "sanitize_email error: sanitized_recipients is not set" if self.class.sanitized_recipients.nil?
+          localish? ? override(:recipients) : real_recipients
+        end
+        
+        def cc(*addresses)
+          real_cc *addresses
+          localish? ? override(:cc) : real_cc
+        end
+
+        def bcc(*addresses)
+          real_bcc *addresses
+          localish? ? override(:bcc) : real_bcc
+        end
+        
+        #######
+        private
+        #######
+
+        def override(type)
+          real_addresses, sanitized_addresses = 
+            case type
+            when :recipients
+              [real_recipients, self.class.sanitized_recipients]
+            when :cc
+              [real_cc, self.class.sanitized_cc]
+            when :bcc
+              [real_bcc, self.class.sanitized_bcc]
+            else raise "sanitize_email error: unknown email override"
+            end
+          
+          return sanitized_addresses if sanitized_addresses.nil? || !self.class.use_actual_email_as_sanitized_user_name
+
+          out = real_addresses.inject([]) do |result, real_recipient|
+            result << sanitized_addresses.map{|sanitized| "#{real_recipient} <#{sanitized}>"}
+            result
+          end.flatten
+          return out
+        end
+        
+      end
+    end
+  end # end Module SanitizeEmail
+end # end Module NinthBit

data/test/sample_mailer.rb

@@ -0,0 +1,34 @@
+
+require 'rubygems'
+require 'action_mailer'
+
+# configure ActionMailer
+ActionMailer::Base.template_root = "."
+
+require File.join(File.dirname(__FILE__), "..", "lib", 'sanitize_email')
+
+
+class SampleMailer < ActionMailer::Base
+  
+  def gmail_override
+    @recipients = "to_real@email.com"
+    @cc         = "cc_real@email.com"
+    @bcc        = "bcc_real@email.com"
+
+    @subject = "Hello there"
+    
+    part :content_type => "text/html", :body => "Hello there"
+  end
+  
+  def gmail_override_multiple_recipient
+    @recipients = ["to_0_real@email.com", "to_1_real@email.com"]
+    @cc         = "cc_real@email.com"
+    @bcc        = "bcc_real@email.com"
+
+    @subject = "Hello there, multiple"
+    
+    part :content_type => "text/html", :body => "Hello there, multiple."
+    
+  end
+
+end

data/test/sanitize_email_test.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+require 'test/sample_mailer'
+
+class SanitizeEmailTest < Test::Unit::TestCase
+  def setup
+    ENV['RAILS_ENV'] = 'test'
+  end
+  
+  def prepare_sanitizations(to = nil, cc = nil, bcc = nil, use_actual_email_as_sanitized_user_name = false)
+    ActionMailer::Base.sanitized_recipients = to
+    ActionMailer::Base.sanitized_cc         = cc
+    ActionMailer::Base.sanitized_bcc        = bcc
+    ActionMailer::Base.local_environments = %w( test )
+    ActionMailer::Base.use_actual_email_as_sanitized_user_name = use_actual_email_as_sanitized_user_name
+  end
+
+  def test_send_can_override_recips_cc_bcc_all_independently
+    prepare_sanitizations("to_sanitized@email.com", "cc_sanitized@email.com")
+    
+    tmail = SampleMailer.create_gmail_override
+    assert_equal ["to_sanitized@email.com"], tmail.to
+    assert_equal ["cc_sanitized@email.com"], tmail.cc
+    assert_equal nil,                        tmail.bcc
+  end
+  
+  def test_to_with_override
+    prepare_sanitizations("to_sanitized@email.com", nil, nil, :override_username)
+    tmail = SampleMailer.create_gmail_override
+    assert_equal "to_real@email.com", tmail.to_addrs[0].name
+    assert_equal "to_sanitized@email.com", tmail.to_addrs[0].address
+  end
+  
+  def test_tcc_with_override
+    prepare_sanitizations("to_sanitized@email.com", "cc_sanitized@email.com", nil, :override_username)
+    tmail = SampleMailer.create_gmail_override
+    assert_equal "cc_real@email.com", tmail.cc_addrs[0].name
+    assert_equal "cc_sanitized@email.com", tmail.cc_addrs[0].address
+  end
+  
+  def test_bcc_with_override
+    prepare_sanitizations("to_sanitized@email.com", nil, "bcc_sanitized@email.com", :override_username)
+    tmail = SampleMailer.create_gmail_override
+    assert_equal "bcc_real@email.com", tmail.bcc_addrs[0].name
+    assert_equal "bcc_sanitized@email.com", tmail.bcc_addrs[0].address
+  end
+  
+  def test_override_with_multiple_santiized_emails
+    prepare_sanitizations(["to_0_sanitized@email.com", "to_1_sanitized@email.com"], nil, nil, :override_username)
+    tmail = SampleMailer.create_gmail_override
+    tmail.to_addrs.each_with_index do |mail, idx|
+      assert_equal "to_real@email.com", mail.name
+      assert_equal "to_#{idx}_sanitized@email.com", mail.address
+    end
+  end
+  
+  def test_overriding_multiple_real_addresses
+    prepare_sanitizations("to_sanitized@email.com", nil, nil, :override_username)
+    tmail = SampleMailer.create_gmail_override_multiple_recipient
+    tmail.to_addrs.each_with_index do |mail, idx|
+      assert_equal "to_#{idx}_real@email.com", mail.name
+      assert_equal "to_sanitized@email.com", mail.address
+    end
+  end
+  
+  def test_overriding_multiple_real_addresses_with_multiple_sanitized_emails
+    prepare_sanitizations(["to_0_sanitized@email.com", "to_1_sanitized@email.com"], nil, nil, :override_username)
+    tmail = SampleMailer.create_gmail_override_multiple_recipient
+
+    assert tmail.to_addrs.map(&:name).include?("to_0_real@email.com")
+    assert tmail.to_addrs.map(&:name).include?("to_1_real@email.com")
+    
+    assert tmail.to_addrs.map(&:address).include?("to_0_sanitized@email.com")
+    assert tmail.to_addrs.map(&:address).include?("to_1_sanitized@email.com")
+  end
+  
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: george-sanitize_email
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- John Trupiano
+- Peter Boling
+- George Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: allows you to play with your application's email abilities without worrying that emails will get sent to actual live addresses
+email: 
+- jtrupiano@gmail.com
+- george@benevolentcode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/sanitize_email/custom_environments.rb
+- lib/sanitize_email/sanitize_email.rb
+- lib/sanitize_email.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- VERSION.yml
+- test/sample_mailer.rb
+- test/sanitize_email_test.rb
+has_rdoc: true
+homepage: http://github.com/george/sanitize_email
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: "Gemified fork of pboling's sanitize_email plugin: allows you to play with your application's email abilities without worrying that emails will get sent to actual live addresses."
+test_files: []
+