address_standardization 0.3.0 → 0.4.0

data/.gitignore

@@ -1,3 +1,3 @@
+.svn
 .DS_Store
-*.gemspec
 *.gem

data/{README.rdoc → README.md}

@@ -22,36 +22,41 @@ Right now this library supports two services: MelissaData and Google Maps.
 
 MelissaData provides two services itself: [US address lookup](http://www.melissadata.com/lookups/AddressVerify.asp) and [Canadian address lookup](http://www.melissadata.com/lookups/CanadianAddressVerify.asp). They both work the same way, however. First, here's how to standardize a US address:
 
-    addr = AddressStandardization::MelissaData::USAddress.standardize(
+    addr = AddressStandardization::MelissaData.standardize_address(
       :street => "1 Infinite Loop",
       :city => "Cupertino",
       :state => "CA"
     )
   
-This submits the address to MelissaData. If the address can't be found, you'll get back `nil`. But if the address can be found (as in this case), you'll get an instance of `AddressStandardization::MelissaData::USAddress`. If you store the instance, you can refer to the individual fields like so:
+This submits the address to MelissaData. If the address can't be found, you'll get back `nil`. But if the address can be found (as in this case), you'll get an instance of `AddressStandardization::Address`. If you store the instance, you can refer to the individual fields like so:
 
     addr.street  #=> "1 INFINITE LOOP"
     addr.city    #=> "CUPERTINO"
     addr.state   #=> "CA"
     addr.zip     #=> "95014-2083"
+    addr.country #=> "USA"
 
 And standardizing a Canadian address:
 
-    addr = AddressStandardization::MelissaData::CanadianAddress.standardize(
+    addr = AddressStandardization::MelissaData.standardize_address(
       :street => "103 Metig St",
       :city => "Sault Ste Marie",
-      :province => "ON"
+      :province => "ON",
+      :country => "Canada"
     )
     addr.street      #=> "103 METIG ST RR 4"
     addr.city        #=> "SAULT STE MARIE"
     addr.province    #=> "ON"
     addr.postalcode  #=> "P6A 5K9"
+    addr.country     #=> "CANADA"
+
+Note that when standardizing a Canadian address, the `:country` must be "Canada" (or "CANADA", or anything like that). Otherwise it will be treated as a US address.
 
-Note that we refer to the province as `province`, but `state` works too. The postal code may also be referred to as `zip`.
+Also note that I'm referring to the address's province as `province`, but you can also use `state` if you like. Same goes for the postal code -- you can also refer to it as `zip`.
 
 Using Google Maps to validate an address is just as easy:
 
-    addr = AddressStandardization::GoogleMaps::Address.standardize(
+    addr = AddressStandardization::GoogleMaps.standardize_address(
       :street => "1600 Amphitheatre Parkway",
       :city => "Mountain View",
       :state => "CA"
@@ -64,7 +69,7 @@ Using Google Maps to validate an address is just as easy:
   
 And, again, a Canadian address:
 
-    addr = AddressStandardization::GoogleMaps::Address.standardize(
+    addr = AddressStandardization::GoogleMaps.standardize_address(
       :street => "1770 Stenson Blvd.",
       :city => "Peterborough",
       :province => "ON"
@@ -87,4 +92,4 @@ If you find any bugs with this plugin, feel free to:
 
 ## Author/License
 
-(c) 2008 Elliot Winkler. Released under the MIT license.
+(c) 2008-2010 Elliot Winkler. Released under the MIT license.

data/Rakefile

@@ -1,9 +1,12 @@
 require 'rubygems'
 require 'rake'
 
+require File.dirname(__FILE__) + "/lib/address_standardization/version.rb"
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
+    gem.version = AddressStandardization::VERSION
     gem.name = "address_standardization"
     gem.summary = %Q{A tiny Ruby library to quickly standardize a postal address}
     gem.description = %Q{A tiny Ruby library to quickly standardize a postal address}
@@ -11,8 +14,7 @@ begin
     gem.email = "elliot.winkler@gmail.com"
     gem.homepage = "http://github.com/mcmire/address_standardization"
     gem.add_dependency "mechanize"
-    gem.add_dependency "hpricot"
-    gem.add_development_dependency "mcmire-contest"
+    gem.add_development_dependency "mcmire-context"
     gem.add_development_dependency "mcmire-matchy"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
@@ -41,7 +43,7 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
+task :test => [:"check_dependencies:development", :check_dependencies]
 
 task :default => :test
 

data/address_standardization.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{address_standardization}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Elliot Winkler"]
+  s.date = %q{2010-02-01}
+  s.description = %q{A tiny Ruby library to quickly standardize a postal address}
+  s.email = %q{elliot.winkler@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md",
+     "TODO"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.md",
+     "Rakefile",
+     "TODO",
+     "address_standardization.gemspec",
+     "lib/address_standardization.rb",
+     "lib/address_standardization/abstract_service.rb",
+     "lib/address_standardization/address.rb",
+     "lib/address_standardization/class_level_inheritable_attributes.rb",
+     "lib/address_standardization/google_maps.rb",
+     "lib/address_standardization/melissa_data.rb",
+     "lib/address_standardization/ruby_ext.rb",
+     "lib/address_standardization/version.rb",
+     "test/google_maps_test.rb",
+     "test/melissa_data_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mcmire/address_standardization}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A tiny Ruby library to quickly standardize a postal address}
+  s.test_files = [
+    "test/google_maps_test.rb",
+     "test/melissa_data_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mechanize>, [">= 0"])
+      s.add_development_dependency(%q<mcmire-context>, [">= 0"])
+      s.add_development_dependency(%q<mcmire-matchy>, [">= 0"])
+    else
+      s.add_dependency(%q<mechanize>, [">= 0"])
+      s.add_dependency(%q<mcmire-context>, [">= 0"])
+      s.add_dependency(%q<mcmire-matchy>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mechanize>, [">= 0"])
+    s.add_dependency(%q<mcmire-context>, [">= 0"])
+    s.add_dependency(%q<mcmire-matchy>, [">= 0"])
+  end
+end
+

data/lib/address_standardization.rb

@@ -1,9 +1,28 @@
 # address_standardization: A tiny Ruby library to quickly standardize a postal address.
-# Copyright (C) 2008 Elliot Winkler. Released under the MIT license.
+# Copyright (C) 2008-2010 Elliot Winkler. Released under the MIT license.
 
-require File.dirname(__FILE__)+'/address_standardization/ruby_ext'
-require File.dirname(__FILE__)+'/address_standardization/class_level_inheritable_attributes'
+require 'mechanize'
 
-require File.dirname(__FILE__)+'/address_standardization/abstract_address'
-require File.dirname(__FILE__)+'/address_standardization/melissa_data'
-require File.dirname(__FILE__)+'/address_standardization/google_maps'
+require 'address_standardization/ruby_ext'
+require 'address_standardization/class_level_inheritable_attributes'
+        
+require 'address_standardization/address'
+require 'address_standardization/abstract_service'
+require 'address_standardization/melissa_data'
+require 'address_standardization/google_maps'
+
+module AddressStandardization
+  class << self
+    attr_accessor :test_mode
+    alias_method :test_mode?, :test_mode
+    
+    attr_accessor :debug_mode
+    alias_method :debug_mode?, :debug_mode
+    
+    def debug(*args)
+      puts(*args) if debug_mode?
+    end
+  end
+  self.test_mode = false
+  self.debug_mode = $DEBUG || ENV["DEBUG"] || false
+end

data/lib/address_standardization/abstract_service.rb

@@ -0,0 +1,31 @@
+module AddressStandardization
+  class AbstractService
+    extend ClassLevelInheritableAttributes
+    cattr_inheritable :canned_response
+    self.canned_response = :success
+    
+    class << self
+      def standardize_address(address_info)
+        if AddressStandardization.test_mode?
+          get_canned_response(address_info)
+        else
+          get_live_response(address_info)
+        end
+      end
+      
+      def with_canned_response(response, &block)
+        old_response = self.canned_response
+        self.canned_response = response
+        ret = yield
+        self.canned_response = old_response
+        ret
+      end
+      
+    protected
+      def get_canned_response(address_info)
+        response = (self.canned_response ||= :success)
+        response == :success ? Address.new(address_info) : nil
+      end
+    end
+  end
+end

data/lib/address_standardization/{abstract_address.rb → address.rb}

@@ -1,21 +1,20 @@
+# TODO: Rename to address.rb
+
 module AddressStandardization
   class StandardizationError < StandardError; end
   
-  class AbstractAddress
-    
-    extend ClassLevelInheritableAttributes
-    cattr_inheritable :valid_keys
-      
-    def self.standardize
-      raise NotImplementedError, "You must override .standardize in a subclass"
+  class Address
+    class << self
+      attr_accessor :valid_keys
     end
+    self.valid_keys = %w(street city state province zip postalcode country)
     
     attr_reader :address_info
   
     def initialize(address_info)
       raise NotImplementedError, "You must define valid_keys" unless self.class.valid_keys
       raise ArgumentError, "No address given!" if address_info.empty?
-      address_info = address_info.inject({}) {|h,(k,v)| h[k.to_s] = v; h }  # stringify keys
+      address_info = address_info.stringify_keys
       validate_keys(address_info)
       standardize_values!(address_info)
       @address_info = address_info
@@ -43,7 +42,7 @@ module AddressStandardization
     end
     
     def ==(other)
-      other.kind_of?(AbstractAddress) && @address_info == other.address_info
+      other.kind_of?(self.class) && @address_info == other.address_info
     end
     
   private

data/lib/address_standardization/google_maps.rb

@@ -1,59 +1,54 @@
-require 'rubygems'
-require 'hpricot'
-
 module AddressStandardization
-  module GoogleMaps
+  # See <http://code.google.com/apis/maps/documentation/geocoding/>
+  class GoogleMaps < AbstractService
     class << self
       attr_accessor :api_key
-    end
     
-    class Address < AbstractAddress
-      self.valid_keys = %w(street city state province postalcode zip country full_address precision)
-      
-      class << self
-        # much of this code was borrowed from GeoKit, thanks...
-        def standardize(address_info)
-          raise "API key not specified.\nCall AddressStandardization::GoogleMaps.api_key = '...' before you call .standardize()." unless GoogleMaps.api_key
-          
-          address_str = "%s, %s, %s %s" % [
-            address_info[:street],
-            address_info[:city],
-            (address_info[:state] || address_info[:province]),
-            address_info[:zip]
-          ]
-          url = "http://maps.google.com/maps/geo?q=#{address_str.url_escape}&output=xml&key=#{GoogleMaps.api_key}&oe=utf-8"
-          # puts url
-          uri = URI.parse(url)
-          res = Net::HTTP.get_response(uri)
-          unless res.is_a?(Net::HTTPSuccess)
-            File.open("test.xml", "w") {|f| f.write("(no response or response was unsuccessful)") }
-            return nil 
-          end
-          xml = res.body
-          #File.open("test.xml", "w") {|f| f.write(xml) }
-          xml = Hpricot::XML(xml)
-          
-          if xml.at("//kml/Response/Status/code").inner_text == "200"
-            addr = {}
-            
-            addr[:street] = get_inner_text(xml, '//ThoroughfareName')
-            addr[:city] = get_inner_text(xml, '//LocalityName')
-            addr[:province] = addr[:state] = get_inner_text(xml, '//AdministrativeAreaName')
-            addr[:zip] = addr[:postalcode] = get_inner_text(xml, '//PostalCodeNumber')
-            addr[:country] = get_inner_text(xml, '//CountryName')
-            
-            new(addr)
-          else
-            #File.open("test.xml", "w") {|f| f.write("(no response or response was unsuccessful)") }
-            nil
-          end
-        end
+    protected
+      # much of this code was borrowed from GeoKit, thanks...
+      def get_live_response(address_info)
+        raise "API key not specified.\nCall AddressStandardization::GoogleMaps.api_key = '...' before you call .standardize()." unless GoogleMaps.api_key
+        
+        address_info = address_info.stringify_keys
+        
+        address_str = [
+          address_info["street"],
+          address_info["city"],
+          (address_info["state"] || address_info["province"]),
+          address_info["zip"]
+        ].join(" ")
+        url = "http://maps.google.com/maps/geo?q=#{address_str.url_escape}&output=xml&key=#{GoogleMaps.api_key}&oe=utf-8"
+        AddressStandardization.debug "[GoogleMaps] Hitting URL: #{url}"
+        uri = URI.parse(url)
+        res = Net::HTTP.get_response(uri)
+        return unless res.is_a?(Net::HTTPSuccess)
+        
+        content = res.body
+        AddressStandardization.debug "[GoogleMaps] Response body:"
+        AddressStandardization.debug "--------------------------------------------------"
+        AddressStandardization.debug content
+        AddressStandardization.debug "--------------------------------------------------"
+        xml = Nokogiri::XML(content)
+        xml.remove_namespaces! # good or bad? I say good.
+        return unless xml.at("/kml/Response/Status/code").inner_text == "200"
+        
+        addr = {}
         
-      private
-        def get_inner_text(xml, xpath)
-          lambda {|x| x && x.inner_text.upcase }.call(xml.at(xpath))
-        end
+        addr[:street]   = get_inner_text(xml, '//ThoroughfareName').to_s
+        addr[:city]     = get_inner_text(xml, '//LocalityName').to_s
+        addr[:province] = addr[:state] = get_inner_text(xml, '//AdministrativeAreaName').to_s
+        addr[:zip]      = addr[:postalcode] = get_inner_text(xml, '//PostalCodeNumber').to_s
+        addr[:country]  = get_inner_text(xml, '//CountryName').to_s
+        
+        return if addr[:street] =~ /^\s*$/ or addr[:city]  =~ /^\s*$/
+        
+        Address.new(addr)
       end
-    end # Address
-  end # GoogleMaps
-end # AddressStandardization
+      
+    private
+      def get_inner_text(xml, xpath)
+        lambda {|x| x && x.inner_text.upcase }.call(xml.at(xpath))
+      end
+    end
+  end
+end

data/lib/address_standardization/melissa_data.rb

@@ -1,69 +1,69 @@
-require 'rubygems'
-require 'mechanize'
+# encoding: utf-8
 
 module AddressStandardization
-  class MelissaData
-    class BaseAddress < AbstractAddress
-      cattr_inheritable :start_url
-      
-      def initialize(address_info)
-        raise NotImplementedError, "You must define start_url" unless self.class.start_url
-        super(address_info)
-      end
-      
-      class << self
-      protected
-        def standardize(address_info, action, attrs_to_fields)
-          is_canada = (action =~ /Canadian/)
-          addr = new(address_info)
-          fields = nil
-          WWW::Mechanize.new do |ua|
-            form_page = ua.get(start_url)
-            form = form_page.form_with(:action => action) do |form|
-              attrs_to_fields.each do |attr, field|
-                form[field] = addr.send(attr)
-              end
-            end
-            results_page = form.submit(form.buttons.first)
+  class MelissaData < AbstractService
+    class << self
+    protected
+      def get_live_response(address_info)
+        address_info = address_info.stringify_keys
+        
+        is_canada = (address_info["country"].to_s.upcase == "CANADA")
+        addr = Address.new(address_info)
+        
+        url = "http://www.melissadata.com/lookups/#{action(is_canada)}"
+        params = []
+        attrs_to_fields(is_canada).each do |attr, field|
+          key, val = field, address_info[attr]
+          params << "#{key}=#{val.url_escape}" if val
+        end
+        url << "?" + params.join("&")
+        url << "&FindAddress=Submit"
+        
+        #puts "URL: <#{url}>"
+        
+        attrs = {:country => (is_canada ? "CANADA" : "USA")}
+        WWW::Mechanize.new do |ua|
+          AddressStandardization.debug "[MelissaData] Hitting URL: #{url}"
+          results_page = ua.get(url)
+          AddressStandardization.debug "[MelissaData] Response body:"
+          AddressStandardization.debug "--------------------------------------------------"
+          AddressStandardization.debug results_page.body
+          AddressStandardization.debug "--------------------------------------------------"
 
-            table = results_page.search("table.Tableresultborder")[1]
-            return unless table
-            status_row = table.at("span.Titresultableok")
-            return unless status_row && status_row.inner_text =~ /Address Verified/
-            main_td = table.search("tr:eq(#{is_canada ? 2 : 3})/td:eq(2)")
-            street_part, city_state_zip_part = main_td.inner_html.split("<br>")[0..1]
-            street = street_part.strip_html.strip_whitespace
-            city, state, zip = city_state_zip_part.strip_html.split("\240\240")
-            #pp :main_td => main_td.to_s,
-            #   :street_part => street_part,
-            #   :city_state_zip_part => city_state_zip_part
-            fields = [ street.upcase, city.upcase, state.upcase, zip.upcase ]
+          table = results_page.search("table.Tableresultborder")[1]
+          return unless table
+          status_row = table.at("span.Titresultableok")
+          return unless status_row && status_row.inner_text =~ /Address Verified/
+          main_td = table.search("tr:eq(#{is_canada ? 2 : 3})/td:eq(2)")
+          main_td_s = main_td.inner_html
+          main_td_s.encode!("utf-8") if main_td_s.respond_to?(:encode!)
+          street_part, city_state_zip_part = main_td_s.split("<br>")[0..1]
+          street = street_part.strip_html.strip_whitespace
+          if main_td_s.respond_to?(:encode!)
+            # ruby 1.9
+            separator = city_state_zip_part.include?("&#160;&#160;") ? "&#160;&#160;" : "  "
+          else
+            # ruby 1.8
+            separator = "\240\240"
           end
-          fields
+          city, state, zip = city_state_zip_part.strip_html.split(separator)
+          attrs[:street] = street.upcase
+          attrs[:city] = city.upcase
+          attrs[:province] = attrs[:state] = state.upcase
+          attrs[:postalcode] = attrs[:zip] = zip.upcase
         end
+        Address.new(attrs)
       end
-    end
-    
-    class USAddress < BaseAddress
-      self.start_url = 'http://www.melissadata.com/lookups/AddressVerify.asp'
-      self.valid_keys = %w(street city state zip)
       
-      def self.standardize(address_info)
-        if fields = super(address_info, "AddressVerify.asp", :street => 'Address', :city => 'city', :state => 'state', :zip => 'zip')
-          street, city, state, zip = fields
-          new(:street => street, :city => city, :state => state, :zip => zip)
-        end
+      def action(is_canada)
+        is_canada ? "CanadianAddressVerify.asp" : "AddressVerify.asp"
       end
-    end
-    
-    class CanadianAddress < BaseAddress
-      self.start_url = 'http://www.melissadata.com/lookups/CanadianAddressVerify.asp'
-      self.valid_keys = %w(street city province postalcode)
       
-      def self.standardize(address_info)
-        if fields = super(address_info, "CanadianAddressVerify.asp", :street => 'Street', :city => 'city', :province => 'Province', :postalcode => 'Postcode')
-          street, city, province, postalcode = fields
-          new(:street => street, :city => city, :province => province, :postalcode => postalcode)
+      def attrs_to_fields(is_canada)
+        if is_canada
+          {"street" => 'Street', "city" => 'city', "province" => 'Province', "postalcode" => 'Postcode'}
+        else
+          {"street" => 'Address', "city" => 'city', "state" => 'state', "zip" => 'zip'}
         end
       end
     end

data/lib/address_standardization/ruby_ext.rb

@@ -14,4 +14,10 @@ class String
       '%' + $1.unpack('H2' * $1.size).join('%').upcase
     end.tr(' ', '+')
   end
+end
+
+class Hash
+  def stringify_keys
+    self.inject({}) {|h,(k,v)| h[k.to_s] = v; h }
+  end
 end

data/lib/address_standardization/version.rb

@@ -0,0 +1,3 @@
+module AddressStandardization
+  VERSION = "0.4.0"
+end

data/test/google_maps_test.rb

@@ -3,46 +3,120 @@ require 'test_helper'
 AddressStandardization::GoogleMaps.api_key = "ABQIAAAALHg3jKnK9wN9K3_ArJA6TxSTZ2OgdK08l2h0_gdsozNQ-6zpaxQvIY84J7Mh1fAHQrYGI4W27qKZaw"
 
 class GoogleMapsTest < Test::Unit::TestCase
-  test "A valid US address" do
-    addr = AddressStandardization::GoogleMaps::Address.standardize(
-      :street => "1600 Amphitheatre Parkway",
-      :city => "Mountain View",
-      :state => "CA"
-    )
-    addr.should == AddressStandardization::GoogleMaps::Address.new(
-      "street" => "1600 AMPHITHEATRE PKWY",
-      "city" => "MOUNTAIN VIEW",
-      "state" => "CA",
-      "province" => "CA",
-      "postalcode" => "94043",
-      "zip" => "94043",
-      "country" => "USA"
-    )
+  shared "production mode tests" do
+    test "A valid US address" do
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        "street" => "1600 Amphitheatre Parkway",
+        :city => "Mountain View",
+        :state => "CA"
+      )
+      addr.should == AddressStandardization::Address.new(
+        "street" => "1600 AMPHITHEATRE PKWY",
+        "city" => "MOUNTAIN VIEW",
+        "state" => "CA",
+        "province" => "CA",
+        "postalcode" => "94043",
+        "zip" => "94043",
+        "country" => "USA"
+      )
+    end
+  
+    test "A valid Canadian address" do
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "1770 Stenson Boulevard",
+        :city => "Peterborough",
+        "province" => "ON"
+      )
+      addr.should == AddressStandardization::Address.new(
+        "street" => "1770 STENSON BLVD",
+        "city" => "PETERBOROUGH",
+        "state" => "ON",
+        "province" => "ON",
+        "postalcode" => "K9K",
+        "zip" => "K9K",
+        "country" => "CANADA"
+      )
+    end
+  
+    test "An invalid address" do    
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should == nil
+    end
+  end
+  
+  context "With test mode explicitly false" do
+    setup do
+      AddressStandardization.test_mode = false
+    end
+    uses "production mode tests"
   end
   
-  test "A valid Canadian address" do
-    addr = AddressStandardization::GoogleMaps::Address.standardize(
-      :street => "1770 Stenson Boulevard",
-      :city => "Peterborough",
-      :province => "ON"
-    )
-    addr.should == AddressStandardization::GoogleMaps::Address.new(
-      "street" => "1770 STENSON BLVD",
-      "city" => "PETERBOROUGH",
-      "state" => "ON",
-      "province" => "ON",
-      "postalcode" => "K9K",
-      "zip" => "K9K",
-      "country" => "CANADA"
-    )
+  context "With test mode implicitly false" do
+    setup do
+      AddressStandardization.test_mode = nil
+    end
+    uses "production mode tests"
   end
   
-  test "An invalid address" do    
-    addr = AddressStandardization::GoogleMaps::Address.standardize(
-      :street => "123 Imaginary Lane",
-      :city => "Some Town",
-      :state => "AK"
-    )
-    addr.should == nil
+  context "With test mode true" do
+    setup do
+      AddressStandardization.test_mode = true
+    end
+    
+    test "Valid address (before and after)" do
+      AddressStandardization::GoogleMaps.canned_response = :success
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should == AddressStandardization::Address.new(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      AddressStandardization::GoogleMaps.canned_response = nil
+    end
+    
+    test "Valid address (block)" do
+      AddressStandardization::GoogleMaps.with_canned_response(:success) do
+        addr = AddressStandardization::GoogleMaps.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.should == AddressStandardization::Address.new(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+      end
+    end
+    
+    test "Invalid address (before and after)" do
+      AddressStandardization::GoogleMaps.canned_response = :failure
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should == nil
+      AddressStandardization::GoogleMaps.canned_response = nil
+    end
+    
+    test "Invalid address (block)" do
+      AddressStandardization::GoogleMaps.with_canned_response(:failure) do
+        addr = AddressStandardization::GoogleMaps.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.should == nil
+      end
+    end
   end
 end

data/test/melissa_data_test.rb

@@ -1,49 +1,148 @@
 require 'test_helper'
 
 class MelissaDataTest < Test::Unit::TestCase
-  test "Valid US address" do
-    addr = AddressStandardization::MelissaData::USAddress.standardize(
-      :street => "1 Infinite Loop",
-      :city => "Cupertino",
-      :state => "CA"
-    )
-    addr.should == AddressStandardization::MelissaData::USAddress.new(
-      "street" => "1 INFINITE LOOP",
-      "city" => "CUPERTINO",
-      "state" => "CA",
-      "zip" => "95014-2083"
-    )
+  shared "production mode tests" do
+    test "Valid US address (implicit country)" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "1 Infinite Loop",
+        "city" => "Cupertino",
+        :state => "CA"
+      )
+      addr.should == AddressStandardization::Address.new(
+        "street" => "1 INFINITE LOOP",
+        "city" => "CUPERTINO",
+        "state" => "CA",
+        "province" => "CA",
+        "zip" => "95014-2083",
+        "postalcode" => "95014-2083",
+        "country" => "USA"
+      )
+    end
+  
+    test "Valid US address (explicit country)" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "1 Infinite Loop",
+        :city => "Cupertino",
+        "state" => "CA",
+        "country" => "USA"
+      )
+      addr.should == AddressStandardization::Address.new(
+        "street" => "1 INFINITE LOOP",
+        "city" => "CUPERTINO",
+        "state" => "CA",
+        "province" => "CA",
+        "zip" => "95014-2083",
+        "postalcode" => "95014-2083",
+        "country" => "USA"
+      )
+    end
+  
+    test "Invalid US address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should == nil
+    end
+  
+    test "Valid Canadian address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        "street" => "3025 Clayhill Rd",
+        :city => "Mississauga",
+        "province" => "ON",
+        :country => "CANADA"
+      )
+      addr.should == AddressStandardization::Address.new(
+        "street" => "3025 CLAYHILL RD",
+        "state" => "ON",
+        "province" => "ON",
+        "city" => "MISSISSAUGA",
+        "zip" => "L5B 4L2",
+        "postalcode" => "L5B 4L2",
+        "country" => "CANADA"
+      )
+    end
+  
+    test "Invalid Canadian address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :province => "BC"
+      )
+      addr.should == nil
+    end
   end
   
-  test "Invalid US address" do
-    addr = AddressStandardization::MelissaData::USAddress.standardize(
-      :street => "123 Imaginary Lane",
-      :city => "Some Town",
-      :state => "AK"
-    )
-    addr.should == nil
+  context "With test mode explicitly false" do
+    setup do
+      AddressStandardization.test_mode = false
+    end
+    uses "production mode tests"
   end
   
-  test "Valid Canadian address" do
-    addr = AddressStandardization::MelissaData::CanadianAddress.standardize(
-      :street => "3025 Clayhill Rd",
-      :city => "Mississauga",
-      :province => "ON"
-    )
-    addr.should == AddressStandardization::MelissaData::CanadianAddress.new(
-      "street" => "3025 CLAYHILL RD",
-      "province" => "ON",
-      "city" => "MISSISSAUGA",
-      "postalcode" => "L5B 4L2"
-    )
+  context "With test mode implicitly false" do
+    setup do
+      AddressStandardization.test_mode = nil
+    end
+    uses "production mode tests"
   end
   
-  test "Invalid Canadian address" do
-    addr = AddressStandardization::MelissaData::CanadianAddress.standardize(
-      :street => "123 Imaginary Lane",
-      :city => "Some Town",
-      :province => "BC"
-    )
-    addr.should == nil
+  context "With test mode true" do
+    setup do
+      AddressStandardization.test_mode = true
+    end
+    
+    test "Valid address (before and after)" do
+      AddressStandardization::MelissaData.canned_response = :success
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :province => "BC"
+      )
+      addr.should == AddressStandardization::Address.new(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :province => "BC"
+      )
+      AddressStandardization::MelissaData.canned_response = nil
+    end
+    
+    test "Valid address (block)" do
+      AddressStandardization::MelissaData.with_canned_response(:success) do
+        addr = AddressStandardization::MelissaData.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :province => "BC"
+        )
+        addr.should == AddressStandardization::Address.new(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :province => "BC"
+        )
+      end
+    end
+    
+    test "Invalid address (before and after)" do
+      AddressStandardization::MelissaData.canned_response = :failure
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :province => "BC"
+      )
+      addr.should == nil
+      AddressStandardization::MelissaData.canned_response = nil
+    end
+    
+    test "Invalid address (block)" do
+      AddressStandardization::MelissaData.with_canned_response(:failure) do
+        addr = AddressStandardization::MelissaData.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :province => "BC"
+        )
+        addr.should == nil
+      end
+    end
   end
 end

data/test/test_helper.rb

@@ -1,12 +1,48 @@
-# http://sneaq.net/textmate-wtf
-#$LOAD_PATH.reject! { |e| e.include? 'TextMate' }
-
-#dir = File.dirname(__FILE__)
-#lib = dir + "/../lib"
-#$LOAD_PATH.unshift(lib)
-
 require 'rubygems'
+gem 'mcmire-context'
 require 'context'
+gem 'mcmire-matchy'
 require 'matchy'
 
-require 'address_standardization'
+require 'address_standardization'
+
+module Context
+  class SharedBehavior < Module
+    # Fix this so that sharing a module twice within two sub-contexts
+    # doesn't fail with something like "'test: blah blah' is already defined"
+    def included(arg) # :nodoc:
+      arg.instance_eval(&@_behavior)
+    end
+  end
+end
+
+class << Test::Unit::TestCase
+  # Modify this so that the constant is set within the current context (and sub-contexts)
+  def shared(name, &block)
+    case name.class.name
+    when "String"
+      name = name.to_module_name
+    when "Symbol"
+      name = name.to_s.to_module_name
+    else
+      raise ArgumentError, "Provide a String or Symbol as the name of the shared behavior group"
+    end
+    const_set(name, Context::SharedBehavior.create_from_behavior(block))
+  end
+  %w(shared_behavior share_as share_behavior_as shared_examples_for).each {|m| alias_method m, :shared}
+  
+  # Modify this so that we look in the current context (and any super-contexts) for the module
+  def use(shared_name)
+    case shared_name.class.name
+    when "Context::SharedBehavior", "Module"
+      include shared_name
+    when "String"
+      include const_get(shared_name.to_module_name)
+    when "Symbol"
+      include const_get(shared_name.to_s.to_module_name)
+    else
+      raise ArgumentError, "Provide a String or Symbol as the name of the shared behavior group or the module name"
+    end
+  end
+  %w(uses it_should_behave_like behaves_like uses_examples_from).each {|m| alias_method m, :use}
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: address_standardization
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Elliot Winkler
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-01 00:00:00 -06:00
+date: 2010-02-01 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,17 +23,7 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: hpricot
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: mcmire-contest
+  name: mcmire-context
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -59,20 +49,22 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
+- README.md
 - TODO
 files: 
 - .gitignore
-- README.rdoc
+- README.md
 - Rakefile
 - TODO
-- VERSION
+- address_standardization.gemspec
 - lib/address_standardization.rb
-- lib/address_standardization/abstract_address.rb
+- lib/address_standardization/abstract_service.rb
+- lib/address_standardization/address.rb
 - lib/address_standardization/class_level_inheritable_attributes.rb
 - lib/address_standardization/google_maps.rb
 - lib/address_standardization/melissa_data.rb
 - lib/address_standardization/ruby_ext.rb
+- lib/address_standardization/version.rb
 - test/google_maps_test.rb
 - test/melissa_data_test.rb
 - test/test_helper.rb

data/VERSION

@@ -1 +0,0 @@
-0.3.0