pluginaweek-validates_as_email_address 0.2.3

data/CHANGELOG.rdoc

@@ -0,0 +1,40 @@
+== master
+
+== 0.2.3 / 2009-04-13
+
+* Update docs
+
+== 0.2.2 / 2009-03-15
+
+* Add support for Rails 2.2 i18n error messages [Saimon Moore]
+
+== 0.2.1 / 2009-01-11
+
+* Ensure correct encoding for regular expressions to be compatible with Ruby 1.9+
+
+== 0.2.0 / 2008-12-14
+
+* Remove the PluginAWeek namespace
+
+== 0.1.1 / 2008-10-25
+
+* Fix major performance hit on long domains when in strict mode
+* Fix single-character/digit domains not being allowed in strict mode
+
+== 0.1.0 / 2008-09-07
+
+* Allow all options to be passed to format/length validations so that future options can be defined without changing this plugin
+* Add support for overriding length limits
+* Add support for requiring that domains follow the RFC 1035 format (on by default) [Kacper Bielecki]
+
+== 0.0.3 / 2008-06-22
+
+* Remove log files from gems
+
+== 0.0.2 / 2008-05-05
+
+* Update documentation
+
+== 0.0.1 / 2007-09-26
+
+* Add documentation

data/LICENSE

@@ -0,0 +1,2 @@
+Licensed under a Creative Commons Attribution-ShareAlike 2.5 License
+http://creativecommons.org/licenses/by-sa/2.5/

data/README.rdoc

@@ -0,0 +1,59 @@
+= validates_as_email_address
+
++validates_as_email_address+ adds support for validating the format/length of
+email addresses.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/validates_as_email_address
+
+Bugs
+
+* http://pluginaweek.lighthouseapp.com/projects/13293-validates_as_email_address
+
+Development
+
+* http://github.com/pluginaweek/validates_as_email_address
+
+Source
+
+* git://github.com/pluginaweek/validates_as_email_address.git
+
+== Description
+
+Consistently reliable email address validations are difficult to find and hard
+to choose as there are far too many implementations in various programming
+languages.  This plugins builds on Thijs van der Vossen's validates_as_email
+by adding advanced validation option support and also validating the length of
+the email address.
+
+== Usage
+
+=== Example
+
+  class Person < ActiveRecord::Base
+    validates_as_email_address :email, :on => :create
+  end
+
+== Testing
+
+Before you can run any tests, the following gem must be installed:
+* plugin_test_helper[http://github.com/pluginaweek/plugin_test_helper]
+
+To run against a specific version of Rails:
+
+  rake test RAILS_FRAMEWORK_ROOT=/path/to/rails
+
+== Dependencies
+
+* Rails 2.0 or later
+
+== References
+
+* Cal Henderson - {Parsing Email Adresses in PHP}[http://iamcal.com/publish/articles/php/parsing_email]
+* Tim Fletcher - {Ruby Translation}[http://tfletcher.com/lib/rfc822.rb]
+* Dan Kubb[dan.kubb@autopilotmarketing.com]
+* Ximon Eighteen[ximon.eightee@int.greenpeace.org]
+* Thijs van der Vossen - validates_as_email[https://svn.greenpeace.org/repositories/rails_plugins/validates_as_email]

data/Rakefile

@@ -0,0 +1,96 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'validates_as_email_address'
+  s.version           = '0.2.3'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Adds support for validating the format/length of email addresses in ActiveRecord'
+  s.description       = s.summary
+  
+  s.files             = FileList['{lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/app_root/{log,log/*,script,script/*}']
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  
+  s.author            = 'Aaron Pfeifer'
+  s.email             = 'aaron@pluginaweek.org'
+  s.homepage          = 'http://www.pluginaweek.org'
+  s.rubyforge_project = 'pluginaweek'
+end
+  
+desc 'Default: run all tests.'
+task :default => :test
+
+desc "Test the #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
+end
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem.'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
+end
+
+desc 'Publish the API documentation.'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pgem, :pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new.configure
+  ruby_forge.login
+  
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'validates_as_email_address'

data/lib/validates_as_email_address.rb

@@ -0,0 +1,87 @@
+require 'validates_as_email_address/rfc_822'
+require 'validates_as_email_address/rfc_1035'
+
+# Adds validations for email addresses
+module ValidatesAsEmailAddress
+  # The default error message to use for improperly formatted e-mail addresses
+  mattr_accessor :invalid_email_message
+  self.invalid_email_message = 'is an invalid email address'
+  
+  # Validates whether the value of the specific attribute matches against the
+  # RFC822/RFC1035 specification.
+  # 
+  #   class Person < ActiveRecord::Base
+  #     validates_as_email_address :email, :on => :create
+  #   end
+  # 
+  # This will also validate that the email address is within the specification
+  # limits, i.e. between 3 and 320 characters in length.
+  # 
+  # Configuration options for length:
+  # * <tt>:minimum</tt> - The minimum size of the attribute
+  # * <tt>:maximum</tt> - The maximum size of the attribute
+  # * <tt>:is</tt> - The exact size of the attribute
+  # * <tt>:within</tt> - A range specifying the minimum and maximum size of the
+  #   attribute
+  # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>
+  # * <tt>:too_long</tt> - The error message if the attribute goes over the
+  #   maximum (default is: "is too long (maximum is %d characters)")
+  # * <tt>:too_short</tt> - The error message if the attribute goes under the
+  #   minimum (default is: "is too short (minimum is %d characters)")
+  # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt>
+  #   method and the attribute is the wrong size (default is:
+  #   "is the wrong length (should be %d characters)")
+  # * <tt>:tokenizer</tt> - Specifies how to split up the attribute string.
+  #   (e.g. <tt>:tokenizer => lambda {|str| str.scan(/\w+/)}</tt> to count
+  #   words.) Defaults to <tt>lambda {|value| value.split(//)}</tt> which
+  #   counts individual characters. 
+  # 
+  # Configuration options for format:
+  # * <tt>:wrong_format</tt> - A custom error message (default is:
+  #   "is an invalid email address")
+  # 
+  # Miscellaneous configuration options:
+  # * <tt>:allow_nil</tt> - Attribute may be nil; skip validation.
+  # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+  # * <tt>:on</tt> - Specifies when this validation is active (default is
+  #   :save, other options :create, :update)
+  # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
+  #   the validation should occur (e.g. :if => :allow_validation, or
+  #   :if => lambda { |user| user.signup_step > 2 }).  The method, proc or
+  #   string should return or evaluate to a true or false value.
+  # * <tt>:strict</tt> - Specifies if the domain part of the email should be
+  #   compliant to RFC 1035 (default is true). If set to false domains such as
+  #   '-online.com', '[127.0.0.1]' become valid.
+  def validates_as_email_address(*attr_names)
+    configuration = attr_names.last.is_a?(Hash) ? attr_names.pop : {}
+    configuration.reverse_merge!(
+      :wrong_format => Object.const_defined?(:I18n) ? :invalid_email : ActiveRecord::Errors.default_error_messages[:invalid_email],
+      :strict => true
+    )
+    
+    # Add format validation
+    format_configuration = configuration.dup
+    format_configuration[:message] = configuration.delete(:wrong_format)
+    format_configuration[:with] = configuration[:strict] ? RFC1035::EmailAddress : RFC822::EmailAddress
+    validates_format_of attr_names, format_configuration
+    
+    # Add length validation
+    length_configuration = configuration.dup
+    length_configuration.reverse_merge!(:within => 3..320) unless ([:minimum, :maximum, :is, :within, :in] & configuration.keys).any?
+    validates_length_of attr_names, length_configuration
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend ValidatesAsEmailAddress
+end
+
+
+# Load default error messages
+if Object.const_defined?(:I18n) # Rails >= 2.2
+  I18n.load_path << "#{File.dirname(__FILE__)}/validates_as_email_address/locale.rb"
+else
+  ActiveRecord::Errors.default_error_messages.update(
+    :invalid_email => ValidatesAsEmailAddress.invalid_email_message
+  )
+end

data/lib/validates_as_email_address/locale.rb

@@ -0,0 +1,9 @@
+{:en => {
+  :activerecord => {
+    :errors => {
+      :messages => {
+        :invalid_email => ValidatesAsEmailAddress.invalid_email_message
+      }
+    }
+  }
+}}

data/lib/validates_as_email_address/rfc_1035.rb

@@ -0,0 +1,28 @@
+module ValidatesAsEmailAddress
+  # The standard describing the format of domains
+  module RFC1035
+    # Matches domain according to the RFC 1035 standard, with the exception
+    # that domains can start with a letter *or* digit
+    Domain = begin
+      digit = '[\\d]'
+      letter = '[\\x61-\\x7a\\x41-\\x5a]'
+      let_dig = "(?:#{letter}|#{digit})"
+      let_dig_hyp = "(?:#{let_dig}|[\\x2d])"
+      label = "#{let_dig}(?:#{let_dig_hyp}*#{let_dig})?"
+      subdomain = "(?:#{label}\\.)*#{label}"
+      domain = "(?:#{subdomain}|\\x20)"
+      
+      /#{domain}/
+    end
+    
+    # Matches email addresses with domains that follow the RFC 1035 standard
+    EmailAddress = begin
+      local_part = RFC822::LocalPart.source
+      domain = Domain.source
+      addr_spec = "(#{local_part})\\x40(#{domain})"
+      addr_spec.force_encoding('binary') if addr_spec.respond_to?(:force_encoding)
+      
+      /\A#{addr_spec}\z/
+    end
+  end
+end

data/lib/validates_as_email_address/rfc_822.rb

@@ -0,0 +1,38 @@
+module ValidatesAsEmailAddress
+  # The standard describing the format of email addresses
+  module RFC822
+    # Matches the two parts of an email address (before/after @)
+    LocalPart, Domain = begin
+      # Shared
+      qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+      dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
+      atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
+      quoted_pair = '\\x5c[\\x00-\\x7f]'
+      domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
+      quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
+      
+      # Local part
+      word = "(?:#{atom}|#{quoted_string})"
+      local_part = "#{word}(?:\\x2e#{word})*"
+      local_part.force_encoding('binary') if local_part.respond_to?(:force_encoding)
+      
+      # Domain
+      domain_ref = atom
+      sub_domain = "(?:#{domain_ref}|#{domain_literal})"
+      domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
+      domain.force_encoding('binary') if domain.respond_to?(:force_encoding)
+      
+      [/#{local_part}/, /#{domain}/]
+    end
+    
+    # Matches email addresses according to the RFC822 standard
+    EmailAddress = begin
+      local_part = LocalPart.source
+      domain = Domain.source
+      addr_spec = "(#{local_part})\\x40(#{domain})"
+      addr_spec.force_encoding('binary') if addr_spec.respond_to?(:force_encoding)
+      
+      /\A#{addr_spec}\z/
+    end
+  end
+end

data/test/app_root/app/models/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/test/app_root/db/migrate/001_create_users.rb

@@ -0,0 +1,11 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :email, :null => false, :limit => 320
+    end
+  end
+  
+  def self.down
+    drop_table :users
+  end
+end

data/test/factory.rb

@@ -0,0 +1,41 @@
+module Factory
+  # Build actions for the model
+  def self.build(model, &block)
+    name = model.to_s.underscore
+    
+    define_method("#{name}_attributes", block)
+    define_method("valid_#{name}_attributes") {|*args| valid_attributes_for(model, *args)}
+    define_method("new_#{name}")              {|*args| new_record(model, *args)}
+    define_method("create_#{name}")           {|*args| create_record(model, *args)}
+  end
+  
+  # Get valid attributes for the model
+  def valid_attributes_for(model, attributes = {})
+    name = model.to_s.underscore
+    send("#{name}_attributes", attributes)
+    attributes.stringify_keys!
+    attributes
+  end
+  
+  # Build an unsaved record
+  def new_record(model, *args)
+    attributes = valid_attributes_for(model, *args)
+    record = model.new(attributes)
+    attributes.each {|attr, value| record.send("#{attr}=", value) if model.accessible_attributes && !model.accessible_attributes.include?(attr) || model.protected_attributes && model.protected_attributes.include?(attr)}
+    record
+  end
+  
+  # Build and save/reload a record
+  def create_record(model, *args)
+    record = new_record(model, *args)
+    record.save!
+    record.reload
+    record
+  end
+  
+  build User do |attributes|
+    attributes.reverse_merge!(
+      :email => 'john.smith@gmail.com'
+    )
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# Load the plugin testing framework
+$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
+require 'rubygems'
+require 'plugin_test_helper'
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+# Mixin the factory helper
+require File.expand_path("#{File.dirname(__FILE__)}/factory")
+Test::Unit::TestCase.class_eval do
+  include Factory
+end

data/test/unit/validates_as_email_address_test.rb

@@ -0,0 +1,329 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ValidatesAsEmailAddressByDefaultTest < ActiveSupport::TestCase
+  def setup
+    User.validates_as_email_address :email
+  end
+  
+  def test_should_not_allow_email_addresses_shorter_than_3_characters
+    user = new_user(:email => 'a@')
+    assert !user.valid?
+    assert user.errors.invalid?(:email)
+    assert_equal 'is an invalid email address', user.errors.on(:email).first
+    
+    user.email = 'a@a'
+    assert user.valid?
+  end
+  
+  def test_should_not_allow_email_addresses_longer_than_320_characters
+    user = new_user(:email => 'a@' + 'a' * 318)
+    assert user.valid?
+    
+    user.email += 'a'
+    assert !user.valid?
+    assert user.errors.invalid?(:email)
+  end
+  
+  def test_should_allow_legal_rfc822_formats
+    [
+      'test@example',
+      'test@example.com', 
+      'test@example.co.uk',
+      '"J. Smith\'s House, a.k.a. Home!"@example.com',
+      'test@123.com',
+    ].each do |address|
+      user = new_user(:email => address)
+      assert user.valid?, "#{address} should be legal."
+    end
+  end
+  
+  def test_should_not_allow_illegal_rfc822_formats
+    [
+      'test@Monday 1:00', 
+      'test@Monday the first',
+      'J. Smith\'s House, a.k.a. Home!@example.com',
+    ].each do |address|
+      user = new_user(:email => address)
+      assert !user.valid?, "#{address} should be illegal."
+      assert user.errors.invalid?(:email)
+    end
+  end
+  
+  def test_should_not_allow_illegal_rfc1035_formats
+    [
+      'test@[127.0.0.1]',
+      'test@-domain-not-starting-with-letter.com',
+      'test@domain-not-ending-with-alphanum-.com'
+    ].each do |address|
+      user = new_user(:email => address)
+      assert !user.valid?, "#{address} should be illegal."
+    end
+  end
+  
+  def teardown
+    User.class_eval do
+      @validate_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_create_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_update_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+    end
+  end
+end
+
+class ValidatesAsEmailAddressTest < ActiveSupport::TestCase
+  def test_should_allow_minimum_length
+    User.validates_as_email_address :email, :minimum => 8
+    
+    user = new_user(:email => 'a@' + 'a' * 6)
+    assert user.valid?
+    
+    user.email.chop!
+    assert !user.valid?
+  end
+  
+  def test_should_not_check_maximum_length_if_minimum_length_defined
+    User.validates_as_email_address :email, :minimum => 10
+    
+    user = new_user(:email => 'a@' + 'a' * 319)
+    assert user.valid?
+  end
+  
+  def test_should_allow_maximum_length
+    User.validates_as_email_address :email, :maximum => 8
+    
+    user = new_user(:email => 'a@' + 'a' * 6)
+    assert user.valid?
+    
+    user.email += 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_not_check_minimum_length_if_maximum_length_defined
+    User.validates_as_email_address :email, :maximum => 8
+    
+    user = new_user(:email => 'a@')
+    assert !user.valid?
+    assert user.errors.invalid?(:email)
+  end
+  
+  def test_should_allow_exact_length
+    User.validates_as_email_address :email, :is => 8
+    
+    user = new_user(:email => 'a@' + 'a' * 6)
+    assert user.valid?
+    
+    user.email.chop!
+    assert !user.valid?
+    
+    user.email += 'aa'
+    assert !user.valid?
+  end
+  
+  def test_should_allow_within_range
+    User.validates_as_email_address :email, :within => 8..9
+    
+    user = new_user(:email => 'a@' + 'a' * 5)
+    assert !user.valid?
+    
+    user.email += 'a'
+    assert user.valid?
+    
+    user.email += 'a'
+    assert user.valid?
+    
+    user.email += 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_allow_in_range
+    User.validates_as_email_address :email, :in => 8..9
+    
+    user = new_user(:email => 'a@' + 'a' * 5)
+    assert !user.valid?
+    
+    user.email += 'a'
+    assert user.valid?
+    
+    user.email += 'a'
+    assert user.valid?
+    
+    user.email += 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_allow_too_long_message
+    User.validates_as_email_address :email, :too_long => 'custom'
+    
+    user = new_user(:email => 'a@' + 'a' * 319)
+    user.valid?
+    
+    assert_equal 'custom', Array(user.errors.on(:email)).last
+  end
+  
+  def test_should_allow_too_short_message
+    User.validates_as_email_address :email, :too_short => 'custom'
+    
+    user = new_user(:email => 'a@')
+    user.valid?
+    
+    assert_equal 'custom', Array(user.errors.on(:email)).last
+  end
+  
+  def test_should_allow_wrong_length_message
+    User.validates_as_email_address :email, :is => 8, :wrong_length => 'custom'
+    
+    user = new_user(:email => 'a@a.com')
+    user.valid?
+    
+    assert_equal 'custom', Array(user.errors.on(:email)).last
+  end
+  
+  def test_should_allow_wrong_format_message
+    User.validates_as_email_address :email, :wrong_format => 'custom'
+    
+    user = new_user(:email => 'a@!')
+    user.valid?
+    
+    assert_equal 'custom', Array(user.errors.on(:email)).first
+  end
+  
+  def test_should_validate_if_if_is_true
+    User.validates_as_email_address :email, :if => lambda {|user| true}
+    
+    user = new_user(:email => 'a')
+    assert !user.valid?
+  end
+  
+  def test_should_not_validate_if_if_is_false
+    User.validates_as_email_address :email, :if => lambda {|user| false}
+    
+    user = new_user(:email => 'a')
+    assert user.valid?
+  end
+  
+  def test_should_validate_if_unless_is_false
+    User.validates_as_email_address :email, :unless => lambda {|user| false}
+    
+    user = new_user(:email => 'a')
+    assert !user.valid?
+  end
+  
+  def test_should_not_validate_if_unless_is_true
+    User.validates_as_email_address :email, :unless => lambda {|user| true}
+    
+    user = new_user(:email => 'a')
+    assert user.valid?
+  end
+  
+  def test_should_validate_if_on_event
+    User.validates_as_email_address :email, :on => :update
+    
+    user = create_user
+    user.email = 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_not_validate_if_not_on_event
+    User.validates_as_email_address :email, :on => :create
+    
+    user = create_user
+    user.email = 'a'
+    assert user.valid?
+  end
+  
+  def test_should_not_validate_if_allow_nil_and_nil
+    User.validates_as_email_address :email, :allow_nil => true
+    
+    user = create_user
+    user.email = nil
+    assert user.valid?
+  end
+  
+  def test_should_validate_if_allow_nil_and_not_nil
+    User.validates_as_email_address :email, :allow_nil => true
+    
+    user = create_user
+    user.email = 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_validate_if_not_allow_nil_and_nil
+    User.validates_as_email_address :email, :allow_nil => false
+    
+    user = create_user
+    user.email = nil
+    assert !user.valid?
+  end
+  
+  def test_should_validate_if_not_allow_nil_and_not_nil
+    User.validates_as_email_address :email, :allow_nil => false
+    
+    user = create_user
+    user.email = 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_not_validate_if_allow_blank_and_blank
+    User.validates_as_email_address :email, :allow_blank => true
+    
+    user = create_user
+    user.email = ''
+    assert user.valid?
+  end
+  
+  def test_should_validate_if_allow_blank_and_not_blank
+    User.validates_as_email_address :email, :allow_blank => true
+    
+    user = create_user
+    user.email = 'a'
+    assert !user.valid?
+  end
+  
+  def test_should_validate_if_not_allow_blank_and_blank
+    User.validates_as_email_address :email, :allow_blank => false
+    
+    user = create_user
+    user.email = ''
+    assert !user.valid?
+  end
+  
+  def test_should_validate_if_not_allow_nil_and_not_nil
+    User.validates_as_email_address :email, :allow_blank => false
+    
+    user = create_user
+    user.email = 'a'
+    assert !user.valid?
+  end
+  
+  def teardown
+    User.class_eval do
+      @validate_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_create_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_update_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+    end
+  end
+end
+
+class ValidatesAsEmailAddressUnrestrictedTest < ActiveSupport::TestCase
+  def setup
+    User.validates_as_email_address :email, :strict => false
+  end
+  
+  def test_should_allow_illegal_rfc1035_formats
+    [
+      'test@[127.0.0.1]',
+      'test@-domain-not-starting-with-letter.com',
+      'test@domain-not-ending-with-alphanum-.com'
+    ].each do |address|
+      user = new_user(:email => address)
+      assert user.valid?, "#{address} should be legal."
+    end
+  end
+  
+  def teardown
+    User.class_eval do
+      @validate_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_create_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+      @validate_on_update_callbacks = ActiveSupport::Callbacks::CallbackChain.new
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: pluginaweek-validates_as_email_address
+version: !ruby/object:Gem::Version 
+  version: 0.2.3
+platform: ruby
+authors: 
+- Aaron Pfeifer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Adds support for validating the format/length of email addresses in ActiveRecord
+email: aaron@pluginaweek.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/validates_as_email_address.rb
+- lib/validates_as_email_address
+- lib/validates_as_email_address/locale.rb
+- lib/validates_as_email_address/rfc_1035.rb
+- lib/validates_as_email_address/rfc_822.rb
+- test/unit
+- test/unit/validates_as_email_address_test.rb
+- test/factory.rb
+- test/app_root
+- test/app_root/app
+- test/app_root/app/models
+- test/app_root/app/models/user.rb
+- test/app_root/db
+- test/app_root/db/migrate
+- test/app_root/db/migrate/001_create_users.rb
+- test/test_helper.rb
+- CHANGELOG.rdoc
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://www.pluginaweek.org
+post_install_message: 
+rdoc_options: []
+
+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: pluginaweek
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Adds support for validating the format/length of email addresses in ActiveRecord
+test_files: 
+- test/unit/validates_as_email_address_test.rb