address-standardization 0.4.2.rc1

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+*.gem
+tags
+*.vim*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.3@address_standardization

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    address-standardization (0.4.1)
+      httparty (~> 0.8.1)
+      logging
+      mechanize (= 2.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    httparty (0.8.1)
+      multi_json
+      multi_xml
+    little-plugger (1.1.3)
+    logging (1.6.1)
+      little-plugger (>= 1.1.2)
+    mechanize (2.0)
+      net-http-digest_auth (~> 1.1, >= 1.1.1)
+      net-http-persistent (~> 1.8)
+      nokogiri (~> 1.4)
+      webrobots (~> 0.0, >= 0.0.9)
+    multi_json (1.0.4)
+    multi_xml (0.4.1)
+    net-http-digest_auth (1.2)
+    net-http-persistent (1.9)
+    nokogiri (1.5.0)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    webrobots (0.0.12)
+      nokogiri (>= 1.4.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  address-standardization!
+  rspec (~> 2.7.0)

data/README.md

@@ -0,0 +1,158 @@
+# address_standardization
+
+## What is it?
+
+Despite the long name, this is a tiny Ruby library to quickly standardize a
+postal address, either via the Google Geocoding API or MelissaData. So if you
+have an online store and you need to verify a shipping address, then you might
+consider using this library.
+
+## What is it *not*?
+
+This is not a library to *geocode* addresses or locations. In other words, you
+won't get world coordinates back for a location. If you need this information,
+then there are other libraries that will do this for you, such as
+[graticule](http://github.com/collectiveidea/graticule) or
+[GeoKit](http://github.com/andre/geokit-gem).
+
+## How do I install it?
+
+    gem install address_standardization
+
+## How do I use it?
+
+Right now this library supports two services: the Google Geocoding API and
+MelissaData. All services work the same way: you call a `standardize_address`
+method with a hash of address data. If the address exists (according to the
+service), you'll get back a full hash of address data. Otherwise, you'll get
+back `nil`.
+
+Both Google and MelissaData have benefits and drawbacks. First, in terms of
+postal addresses there are three kinds of addresses you are probably concerned
+with: US addresses, Canadian addresses, and then international addresses.
+
+### Google
+
+Google is pretty great in that in knows about all sorts of addresses. So if
+you're trying to verify an address in France, then Google probably knows about
+it. However, it is not very useful in terms of standardizing US addresses,
+because it doesn't know what to do with P.O. boxes.
+
+That said, here is how you'd standardize a US address:
+
+    addr = AddressStandardization::GoogleMaps.standardize_address(
+      :street => "1600 Amphitheatre Parkway",
+      :city => "Mountain View",
+      :state => "CA"
+    )
+    addr.street      #=> "1600 AMPHITHEATRE PKWY"
+    addr.city        #=> "MOUNTAIN VIEW"
+    addr.county      #=> "SANTA CLARA"
+    addr.state       #=> "CA"
+    addr.zip         #=> "94043"
+    addr.country     #=> "UNITED STATES"
+
+By default, the `standardize_address` method will leave it up to the service to
+decide which country to scope the address query to. Google may be able to figure
+it out based on the address you provide, but you can always narrow it down by
+providing a `:country` key. So for instance, to standardize a Canadian address:
+
+    addr = AddressStandardization::GoogleMaps.standardize_address(
+      :street => "55 East Cordova St. Apt 415",
+      :city => "Vancouver",
+      :province => "BC",
+      :country => "Canada"
+    )
+    addr.street       #=> "55 E CORDOVA ST"
+    addr.city         #=> "VANCOUVER"
+    addr.district     #=> "GREATER VANCOUVER REGIONAL DISTRICT"
+    addr.province     #=> "ON"
+    addr.postal_code  #=> "V6A 1K3"
+    addr.country      #=> "CANADA"
+
+Note that `province` is an alias for `state`, `district` is an alias for
+`county` and `postal_code` is an alias for `zip`.
+
+And to standardize a French address:
+
+    addr = AddressStandardization::GoogleMaps.standardize_address(
+      :street => "Parvis de Notre Dame",
+      :city => "Paris",
+      :country => "France"
+    )
+    addr.street       #=> "PLACE DU PARVIS NOTRE-DAME"
+    addr.city         #=> "PARIS"
+    addr.region       #=> "ÎLE-DE-FRANCE"
+    addr.postal_code  #=> "75004"
+    addr.country      #=> "FRANCE"
+
+Finally, note what happens if we attempt to standardize a bogus address:
+
+    addr = AddressStandardization::GoogleMaps.standardize_address(
+      :street => "abcdef"
+    )
+    addr  #=> nil
+
+### MelissaData
+
+If you want to simply verify US addresses, then MelissaData is a better bet, as
+it not only understands P.O. boxes, but it is also able to tell whether a unit
+or apartment number is left out of the address (although currently this
+information is not used; there is an
+[open ticket](https://github.com/mcmire/address_standardization/issues/12) to
+do this).
+
+Standardizing a US address works much the same way as with Google:
+
+    addr = AddressStandardization::MelissaData.standardize_address(
+      :street => "1600 Amphitheatre Parkway",
+      :city => "Mountain View",
+      :state => "CA"
+    )
+    addr.street      #=> "1600 AMPHITHEATRE PKWY"
+    addr.city        #=> "MOUNTAIN VIEW"
+    addr.county      #=> "SANTA CLARA"
+    addr.state       #=> "CA"
+    addr.zip         #=> "94043-1351"
+    addr.country     #=> "UNITED STATES"
+
+As mentioned, you can also do P.O. boxes:
+
+    addr = AddressStandardization::MelissaData.standardize_address(
+      :street => 'P.O. Box 400160',
+      :city => 'Charlottesville',
+      :state => 'VA'
+    )
+    addr.street      #=> "PO BOX 400160"
+    addr.city        #=> "CHARLOTTESVILLE"
+    addr.county      #=> "ALBEMARLE"
+    addr.state       #=> "VA"
+    addr.zip         #=> "22904-4160"
+    addr.country     #=> "UNITED STATES"
+
+## How do I hack on it?
+
+* Run `bundle install` to ensure you have all dependencies.
+* Add your changes.
+* Write some tests! Tests are written in RSpec, so `rspec FILE` to run a
+  single test, and `rake test` to run all of the tests.
+* If you're feeling generous, fork the project and submit a pull request. I'll
+  take a look at it when I can.
+
+## Contributors
+
+* Evan Whalen ([evanwhalen](http://github.com/evanwhalen))
+* Ryan Heneise ([mysmallidea](http://github.com/mysmallidea))
+
+## Support
+
+If you need help, you can get in touch with me here on Github, or via:
+
+  * **Twitter**: [@mcmire](http://twitter.com/mcmire)
+  * **Email**: <elliot.winkler@gmail.com>
+
+## Copyright/License
+
+(c) 2008-2011 Elliot Winkler. All code in this project is free to use, modify,
+and redistribute for any purpose, commercial or personal. An attribution, while
+not required, would be appreciated.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+desc "Run all of the tests"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = true
+end
+
+task :default => :spec

data/TODO

@@ -0,0 +1 @@
+* MelissaData will let us know if there are other residents in the building that the address points to and thus whether to supply the suite number -- tap into this

data/address_standardization.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/address_standardization/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Elliot Winkler']
+  gem.email         = ['elliot.winkler@gmail.com']
+  gem.description   = "A tiny Ruby library to quickly standardize a postal address"
+  gem.summary       = "A tiny Ruby library to quickly standardize a postal address"
+  gem.homepage      = 'http://github.com/mcmire/address_standardization'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "address-standardization"
+  gem.require_paths = ["lib"]
+  gem.version       = AddressStandardization::VERSION
+
+  # 2.0.1 contains a bug, hardcode to 2.0.0 for now until 2.1 comes out
+  gem.add_runtime_dependency('mechanize', '2.0.0')
+  gem.add_runtime_dependency('httparty', '~> 0.8.1')
+  gem.add_runtime_dependency('logging', '~> 1.6.1')
+
+  gem.add_development_dependency('rspec', '~> 2.7.0')
+end

data/lib/address_standardization.rb

@@ -0,0 +1,34 @@
+# address_standardization: A tiny Ruby library to quickly standardize a postal address.
+# Copyright (C) 2008-2011 Elliot Winkler. Released under the MIT license.
+
+require 'logging'
+
+# TODO: Force users to require MelissaData or GoogleMaps manually
+# so that no dependency is required without being unused
+require 'mechanize'
+require 'httparty'
+
+here = File.expand_path('..', __FILE__)
+
+require "#{here}/address_standardization/ruby_ext"
+require "#{here}/address_standardization/helpers"
+
+require "#{here}/address_standardization/address"
+require "#{here}/address_standardization/abstract_service"
+require "#{here}/address_standardization/melissa_data"
+require "#{here}/address_standardization/google_maps"
+
+module AddressStandardization
+  class << self
+    attr_accessor :test_mode
+    alias_method :test_mode?, :test_mode
+
+    def logger
+      @_logger ||= Logging.logger(STDOUT)
+    end
+  end
+
+  self.test_mode = false
+
+  logger.level = ($DEBUG || ENV['DEBUG']) ? :debug : :info
+end

data/lib/address_standardization/abstract_service.rb

@@ -0,0 +1,39 @@
+module AddressStandardization
+  class AbstractService
+    class << self
+      attr_accessor :canned_response
+
+      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
+
+      def get_live_response
+        raise NotImplementedError
+      end
+
+      def logger
+        AddressStandardization.logger
+      end
+    end
+
+    self.canned_response = :success
+  end
+end

data/lib/address_standardization/address.rb

@@ -0,0 +1,56 @@
+module AddressStandardization
+  class Address
+    ATTRIBUTE_DEFS = [
+      :street,
+      :city,
+      [:region, :state, :province],
+      [:postal_code, :postcode, :zip],
+      [:district, :county],
+      :country
+    ]
+    ATTRIBUTE_NAMES = ATTRIBUTE_DEFS.flatten
+    UNIQUE_ATTRIBUTE_NAMES = ATTRIBUTE_DEFS.map { |attr|
+      Array === attr ? attr[0] : attr
+    }
+
+    ATTRIBUTE_DEFS.each do |duck|
+      duck = [duck] unless Array === duck
+      name, aliases = duck[0], duck[1..-1]
+
+      attr_reader name
+      define_method(:"#{name}=") do |value|
+        instance_variable_set("@#{name}", value.to_s.upcase)
+      end
+
+      aliases.each do |a|
+        alias_method a, name
+        alias_method "#{a}=", "#{name}="
+      end
+    end
+
+    def initialize(attrs={})
+      attrs.symbolize_keys!
+      _assert_valid_attrs!(attrs)
+      attrs.each do |attr, value|
+        __send__("#{attr}=", Helpers.strip_whitespace(value))
+      end
+    end
+
+    def attributes
+      UNIQUE_ATTRIBUTE_NAMES.inject({}) {|h,k| h[k] = __send__(k); h }
+    end
+
+    def ==(other)
+      self.class === other && attributes == other.attributes
+    end
+
+    def _assert_valid_attrs!(attrs)
+      # assume attrs's keys are already symbols
+      valid_keys = ATTRIBUTE_NAMES
+      invalid_keys = attrs.keys - valid_keys
+      if invalid_keys.any?
+        raise ArgumentError, "You gave invalid attributes: #{invalid_keys.join(', ')}. Valid attributes are: #{valid_keys.join(', ')}"
+      end
+    end
+  end
+end

data/lib/address_standardization/google_maps.rb

@@ -0,0 +1,78 @@
+module AddressStandardization
+  # See http://code.google.com/apis/maps/documentation/geocoding/
+  # for documentation on Google's Geocoding API.
+  class GoogleMaps < AbstractService
+    class << self
+      def api_key; end
+      def api_key=(value)
+        warn "The Google Maps API no longer requires a key, so you are free to remove `AddressStandardization::GoogleMaps.api_key = ...` from your code as it is now a no-op."
+      end
+
+    protected
+      def get_live_response(address_info)
+        # Much of this code was borrowed from GeoKit, specifically:
+        # https://github.com/andre/geokit-gem/blob/master/lib/geokit/geocoders.rb#L530
+
+        address_info = address_info.stringify_keys
+
+        address_str = [
+          address_info["street"],
+          address_info["city"],
+          (address_info["state"] || address_info["province"]),
+          address_info["zip"]
+        ].compact.join(" ")
+        address_country = address_info["country"] || "US"
+
+        resp = HTTParty.get("http://maps.google.com/maps/api/geocode/json",
+          :query => {
+            :sensor => 'false',
+            :address => address_str,
+            :bias => address_country.downcase
+          }
+        )
+        data = resp.parsed_response
+        logger.debug <<EOT
+[GoogleMaps] Response body:
+--------------------------------------------------------------------------------
+#{resp.body}
+--------------------------------------------------------------------------------
+EOT
+        logger.debug <<EOT
+[GoogleMaps] Parsed response:
+--------------------------------------------------------------------------------
+#{data}
+--------------------------------------------------------------------------------
+EOT
+
+        if data['results'].any? && data['status'] == "OK"
+          result = data['results'].first
+          addr = Address.new
+          street = ["", ""]
+          result['address_components'].each do |comp|
+            case
+            when comp['types'].include?("street_number")
+              street[0] = comp['short_name']
+            when comp['types'].include?("route")
+              street[1] = comp['long_name']
+            when comp['types'].include?("locality")
+              addr.city = comp['long_name']
+            when comp['types'].include?("administrative_area_level_1")
+              addr.region = comp['short_name']
+            when comp['types'].include?("postal_code")
+              addr.postal_code = comp['long_name']
+            when comp['types'].include?("country")
+              # addr[:country_code] = comp['short_name']
+              addr.country = comp['long_name']
+            when comp['types'].include?("administrative_area_level_2")
+              addr.district = comp['long_name']
+            end
+          end
+          addr.street = street.join(" ").strip
+          return addr
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/address_standardization/helpers.rb

@@ -0,0 +1,21 @@
+module AddressStandardization
+  module Helpers
+    extend self
+
+    def strip_html(str)
+      str.gsub(/<\/?([^>]+)>/, '')
+    end
+    def strip_newlines(str)
+      str.gsub(/[\r\n]+/, '')
+    end
+    def strip_whitespace(str)
+      strip_newlines(str).squeeze(" ").strip
+    end
+
+    def url_escape(str)
+      str.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+        '%' + $1.unpack('H2' * $1.size).join('%').upcase
+      end.tr(' ', '+')
+    end
+  end
+end

data/lib/address_standardization/melissa_data.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module AddressStandardization
+  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")
+
+        if is_canada
+          raise "The MelissaData adapter doesn't work for Canadian addresses currently. This is a known issue and will be fixed in a future release."
+        end
+
+        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}=#{Helpers.url_escape(val)}" if val
+        end
+        url << "?" + params.join("&")
+        url << "&FindAddress=Submit"
+
+        addr = Address.new(
+          :country => (is_canada ? "Canada" : "United States")
+        )
+        ua = Mechanize.new
+        logger.debug "[MelissaData] Hitting URL: #{url}"
+        results_page = ua.get(url)
+        logger.debug "[MelissaData] Response body:"
+        logger.debug "--------------------------------------------------"
+        logger.debug results_page.body
+        logger.debug "--------------------------------------------------"
+
+        table = results_page.at("table.Tableresultborder")
+        unless table
+          logger.debug "Couldn't find table"
+          return nil
+        end
+        status_row = table.at("div.Titresultableok")
+        unless status_row
+          logger.debug "Couldn't find status_row"
+          return nil
+        end
+        unless status_row.inner_text =~ /Address Verified/
+          logger.debug "Address not verified"
+          return nil
+        end
+        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 = Helpers.strip_whitespace(Helpers.strip_html(street_part))
+        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
+        county_row = table.search('tr.tdresul01')[4]
+        county = county_row.inner_text.match(/County ([A-Za-z ]+)/)[1].strip
+        city, state, zip = Helpers.strip_html(city_state_zip_part).split(separator)
+        addr.street = street
+        addr.city = city
+        addr.province = state
+        addr.postal_code = zip
+        addr.district = county
+
+        return addr
+      end
+
+      def action(is_canada)
+        is_canada ? "CanadianAddressVerify.asp" : "AddressVerify.asp"
+      end
+
+      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
+  end
+end

data/lib/address_standardization/ruby_ext.rb

@@ -0,0 +1,29 @@
+class Hash
+# Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+end

data/lib/address_standardization/version.rb

@@ -0,0 +1,3 @@
+module AddressStandardization
+  VERSION = "0.4.2.rc1"
+end

data/spec/address_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe AddressStandardization::Address do
+  describe '.new' do
+    it "raises an ArgumentError if the given hash contains unknown attributes" do
+      lambda { described_class.new(:foo => 'bar') }.
+        should raise_error(ArgumentError)
+    end
+
+    it "doesn't raise an ArgumentError if given nothing" do
+      lambda { described_class.new }.should_not raise_error
+    end
+
+    it "doesn't raise an ArgumentError if given an empty hash" do
+      lambda { described_class.new({}) }.should_not raise_error
+    end
+
+    it "doesn't raise an ArgumentError if given a valid hash" do
+      lambda { described_class.new(:street => '111 Main St.') }.should_not raise_error
+    end
+
+    it "sets the given attributes" do
+      addr = described_class.new(
+        :street => '111 Main St.',
+        :city => 'Boulder',
+        :state => 'CO'
+      )
+      addr.street.should == '111 Main St.'
+      addr.city.should == 'Boulder'
+      addr.state.should == 'CO'
+    end
+  end
+
+  it "has a street attribute" do
+    subject.street         = 'foo'
+    subject.street.should == 'foo'
+  end
+
+  it "has a city attribute" do
+    subject.city         = 'foo'
+    subject.city.should == 'foo'
+  end
+
+  it "has a region attribute (aliased to state and province)" do
+    subject.region           = 'foo'
+    subject.region.should   == 'foo'
+    subject.state.should    == 'foo'
+    subject.province.should == 'foo'
+
+    subject.state            = 'bar'
+    subject.region.should   == 'bar'
+    subject.state.should    == 'bar'
+    subject.province.should == 'bar'
+
+    subject.province          = 'baz'
+    subject.region.should    == 'baz'
+    subject.state.should     == 'baz'
+    subject.province.should  == 'baz'
+  end
+
+  it "has a postal_code attribute (aliased to postcode and zip)" do
+    subject.postal_code         = 11111
+    subject.postal_code.should == 11111
+    subject.postcode.should    == 11111
+    subject.zip.should         == 11111
+
+    subject.postal_code         = 22222
+    subject.postal_code.should == 22222
+    subject.postcode.should    == 22222
+    subject.zip.should         == 22222
+
+    subject.postal_code         = 33333
+    subject.postal_code.should == 33333
+    subject.postcode.should    == 33333
+    subject.zip.should         == 33333
+  end
+
+  it "has a district attribute (aliased to county)" do
+    subject.district         = 'foo'
+    subject.district.should == 'foo'
+    subject.county.should   == 'foo'
+
+    subject.county           = 'bar'
+    subject.district.should == 'bar'
+    subject.county.should   == 'bar'
+  end
+
+  it "has a country attribute" do
+    subject.country         = 'foo'
+    subject.country.should == 'foo'
+  end
+
+  describe '#attributes' do
+    it "returns all of the attributes as a hash" do
+      subject.street = '111 Main St.'
+      subject.region = 'Georgia'
+      subject.country = 'United States'
+      subject.attributes.should == {
+        :street => '111 Main St.',
+        :city => nil,
+        :region => 'Georgia',
+        :postal_code => nil,
+        :district => nil,
+        :country => 'United States'
+      }
+    end
+  end
+
+  describe '#==' do
+    it "returns false if the given object is not an described_class" do
+      subject.should_not == :foo
+    end
+
+    it "returns false if the attributes of the given described_class don't match this described_class's attributes" do
+      addr1 = described_class.new(
+        :street => '111 Pearl St.',
+        :city => 'Boulder',
+        :state => 'CO'
+      )
+      addr2 = described_class.new(
+        :street => '111 Pearl Pkwy.',
+        :city => 'Boulder',
+        :state => 'CO'
+      )
+      addr1.should_not == addr2
+    end
+
+    it "returns true otherwise" do
+      addr1 = described_class.new(
+        :street => '111 Pearl St.',
+        :city => 'Boulder',
+        :state => 'CO'
+      )
+      addr2 = described_class.new(
+        :street => '111 Pearl St.',
+        :city => 'Boulder',
+        :state => 'CO'
+      )
+      addr1.should == addr2
+    end
+  end
+end

data/spec/google_maps_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe AddressStandardization::GoogleMaps do
+  context 'in production mode' do
+    before do
+      AddressStandardization.test_mode = nil
+    end
+
+    it "returns the correct data for a valid US address" do
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        # test that it works regardless of symbols or strings
+        "street" => "1600 Amphitheatre Parkway",
+        :city => "Mountain View",
+        :state => "CA"
+      )
+      addr.attributes.should == {
+        :street      => "1600 AMPHITHEATRE PKWY",
+        :city        => "MOUNTAIN VIEW",
+        :district    => "SANTA CLARA",
+        :region      => "CA",
+        :postal_code => "94043",
+        :country     => "UNITED STATES"
+      }
+    end
+
+    it "returns the correct data for a valid Canadian address" do
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        # test that it works regardless of symbols or strings
+        :street => "55 East Cordova St. Apt 415",
+        :city => "Vancouver",
+        "province" => "BC"
+      )
+      addr.attributes.should == {
+        :street      => "55 E CORDOVA ST",
+        :city        => "VANCOUVER",
+        :district    => "GREATER VANCOUVER REGIONAL DISTRICT",
+        :region      => "BC",
+        :postal_code => "V6A 1K3",
+        :country     => "CANADA"
+      }
+    end
+
+    it "returns nothing for an invalid address" do
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city   => "Some Town",
+        :state  => "AK"
+      )
+      addr.should be_nil
+    end
+  end
+
+  context 'in test mode' do
+    before do
+      AddressStandardization.test_mode = true
+    end
+
+    it "returns the correct data for a successful response" do
+      AddressStandardization::GoogleMaps.canned_response = :success
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.attributes.should == {
+        :street      => "123 IMAGINARY LANE",
+        :city        => "SOME TOWN",
+        :district    => nil,
+        :region      => "AK",
+        :postal_code => nil,
+        :country     => nil
+      }
+      AddressStandardization::GoogleMaps.canned_response = nil
+
+      # block form
+      AddressStandardization::GoogleMaps.with_canned_response(:success) do
+        addr = AddressStandardization::GoogleMaps.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.attributes.should == {
+          :street      => "123 IMAGINARY LANE",
+          :city        => "SOME TOWN",
+          :district    => nil,
+          :region      => "AK",
+          :postal_code => nil,
+          :country     => nil
+        }
+      end
+    end
+
+    it "returns nothing for an unsuccessful response" do
+      AddressStandardization::GoogleMaps.canned_response = :failure
+      addr = AddressStandardization::GoogleMaps.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should be_nil
+      AddressStandardization::GoogleMaps.canned_response = nil
+
+      # block form
+      AddressStandardization::GoogleMaps.with_canned_response(:failure) do
+        addr = AddressStandardization::GoogleMaps.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.should be_nil
+      end
+    end
+  end
+end

data/spec/melissa_data_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe AddressStandardization::MelissaData do
+  context 'in production mode' do
+    before do
+      AddressStandardization.test_mode = nil
+    end
+
+    it "returns the correct data for a valid US address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        # test that it works regardless of symbols or strings
+        "street" => "1600 Amphitheatre Parkway",
+        :city => "Mountain View",
+        :state => "CA"
+      )
+      addr.attributes.should == {
+        :street      => "1600 AMPHITHEATRE PKWY",
+        :city        => "MOUNTAIN VIEW",
+        :district    => "SANTA CLARA",
+        :region      => "CA",
+        :postal_code => "94043-1351",
+        :country     => "UNITED STATES"
+      }
+    end
+
+    it "returns the correct data for a valid Canadian address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        # test that it works regardless of symbols or strings
+        :street => "55 East Cordova St. Apt 415",
+        :city => "Vancouver",
+        "province" => "BC"
+      )
+      addr.attributes.should == {
+        :street      => "55 E CORDOVA ST",
+        :city        => "VANCOUVER",
+        :district    => "GREATER VANCOUVER REGIONAL DISTRICT",
+        :region      => "BC",
+        :postal_code => "V6A 1K3",
+        :country     => "CANADA"
+      }
+    end
+
+    it "returns nothing for an invalid address" do
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city   => "Some Town",
+        :state  => "AK"
+      )
+      addr.should be_nil
+    end
+  end
+
+  context 'in test mode' do
+    before do
+      AddressStandardization.test_mode = true
+    end
+
+    it "returns the correct data for a successful response" do
+      AddressStandardization::MelissaData.canned_response = :success
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.attributes.should == {
+        :street      => "123 IMAGINARY LANE",
+        :city        => "SOME TOWN",
+        :district    => nil,
+        :region      => "AK",
+        :postal_code => nil,
+        :country     => nil
+      }
+      AddressStandardization::MelissaData.canned_response = nil
+
+      # block form
+      AddressStandardization::MelissaData.with_canned_response(:success) do
+        addr = AddressStandardization::MelissaData.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.attributes.should == {
+          :street      => "123 IMAGINARY LANE",
+          :city        => "SOME TOWN",
+          :district    => nil,
+          :region      => "AK",
+          :postal_code => nil,
+          :country     => nil
+        }
+      end
+    end
+
+    it "returns nothing for an unsuccessful response" do
+      AddressStandardization::MelissaData.canned_response = :failure
+      addr = AddressStandardization::MelissaData.standardize_address(
+        :street => "123 Imaginary Lane",
+        :city => "Some Town",
+        :state => "AK"
+      )
+      addr.should be_nil
+      AddressStandardization::MelissaData.canned_response = nil
+
+      # block form
+      AddressStandardization::MelissaData.with_canned_response(:failure) do
+        addr = AddressStandardization::MelissaData.standardize_address(
+          :street => "123 Imaginary Lane",
+          :city => "Some Town",
+          :state => "AK"
+        )
+        addr.should be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require 'address_standardization'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: address-standardization
+version: !ruby/object:Gem::Version
+  version: 0.4.2.rc1
+  prerelease: 6
+platform: ruby
+authors:
+- Elliot Winkler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: &70277233513360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70277233513360
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70277233512180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70277233512180
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: &70277233510980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70277233510980
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70277233510300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70277233510300
+description: A tiny Ruby library to quickly standardize a postal address
+email:
+- elliot.winkler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- 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/google_maps.rb
+- lib/address_standardization/helpers.rb
+- lib/address_standardization/melissa_data.rb
+- lib/address_standardization/ruby_ext.rb
+- lib/address_standardization/version.rb
+- spec/address_spec.rb
+- spec/google_maps_spec.rb
+- spec/melissa_data_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/mcmire/address_standardization
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A tiny Ruby library to quickly standardize a postal address
+test_files:
+- spec/address_spec.rb
+- spec/google_maps_spec.rb
+- spec/melissa_data_spec.rb
+- spec/spec_helper.rb