street_sweeper 1.0.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+ - 2.2
+ - jruby
+ - rbx-3

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENCE

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

data/README.md

@@ -0,0 +1,70 @@
+[![Build Status](https://travis-ci.org/williamatodd/street_sweeper.svg?branch=master)](https://travis-ci.org/williamatodd/street_sweeper)
+
+# DESCRIPTION
+
+Parses a string returning a normalized Address object. When the string is not an US address it returns nil.
+
+This is a resurrected fork of [StreetSweeper::US](https://github.com/street-address-rb/street-address) which was itself a port of the perl module [Geo::StreetSweeper](https://github.com/timbunce/Geo-StreetAddress-US) originally written by Schuyler D. Erle.
+
+## Installation
+
+```shell
+    gem install StreetSweeper
+```
+
+then in your code
+
+```ruby
+    require 'street_sweeper'
+```
+
+or from Gemfile
+
+```ruby
+    gem 'StreetSweeper', require: "street_sweeper"
+```
+
+## Basic Usage
+
+```ruby
+    require 'street_sweeper'
+
+    address = StreetSweeper.parse("1600 Pennsylvania Ave, Washington, DC, 20500")
+    address.street # Pennsylvania
+    address.number # 1600
+    address.postal_code # 20500
+    address.city # Washington
+    address.state # DC
+    address.state_name # District of columbia
+    address.street_type # Ave
+    address.intersection? # false
+    address.full_street_address # 1600 Pennsylvania Ave, Washington, DC 20500
+
+    address = StreetSweeper.parse("1600 Pennsylvania Ave")
+    address.street # Pennsylvania
+    address.number # 1600
+    address.state # nil
+
+    address = StreetSweeper.parse("5904 Richmond Hwy Ste 340 Alexandria VA 22303-1864")
+    address.street_address_1 # 5904 Richmond Hwy
+    address.street_address_2 # Ste 340
+    address.full_postal_code # 22303-1864
+    address.postal_code_ext # 1846
+    address.state_name # Virginia
+    address.state_fips # 06
+
+```
+## Stricter Parsing
+
+```ruby
+    address = StreetSweeper.parse_address("1600 Pennsylvania Avenue")
+    # nil - not enough information to be a full address
+
+    address = StreetSweeper.parse_address("1600 Pennsylvania Ave, Washington, DC, 20500")
+    # same results as above
+```
+
+## License
+The [MIT License](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2007-2018 Contributors

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+# If you want to make this the default task
+task default: :spec

data/lib/street_sweeper.rb

@@ -0,0 +1,4 @@
+require 'street_sweeper/constants'
+require 'street_sweeper/matchers'
+require 'street_sweeper/address'
+require 'street_sweeper/base'

data/lib/street_sweeper/address.rb

@@ -0,0 +1,103 @@
+module StreetSweeper
+  class Address
+    attr_accessor(
+      :number,
+      :street,
+      :street_type,
+      :unit,
+      :unit_prefix,
+      :suffix,
+      :prefix,
+      :city,
+      :state,
+      :postal_code,
+      :postal_code_ext,
+      :street2,
+      :street_type2,
+      :suffix2,
+      :prefix2,
+      :redundant_street_type
+    )
+
+    def initialize(args)
+      args.each do |attr, val|
+        public_send("#{attr}=", val)
+      end
+    end
+
+    def full_postal_code
+      return nil unless postal_code
+      postal_code_ext ? "#{postal_code}-#{postal_code_ext}" : postal_code
+    end
+
+    def state_fips
+      Constants::FIPS_STATES[state]
+    end
+
+    def state_name
+      (name = Constants::STATE_NAMES[state]) && name.capitalize
+    end
+
+    def intersection?
+      !street2.nil?
+    end
+
+    def line1
+      parts = []
+      if intersection?
+        parts << prefix if prefix
+        parts << street
+        parts << street_type if street_type
+        parts << suffix if suffix
+        parts << 'and'
+        parts << prefix2 if prefix2
+        parts << street2
+        parts << street_type2 if street_type2
+        parts << suffix2 if suffix2
+      else
+        parts << street_address_1
+        parts << street_address_2
+      end
+      parts.join(' ').strip
+    end
+
+    def line2
+      parts = []
+      parts << city  if city
+      parts << state if state
+      s = parts.join(', ')
+      s += " #{full_postal_code}" if full_postal_code
+      s.strip
+    end
+
+    def street_address_1
+      return line1 if intersection?
+      parts = []
+      parts << number
+      parts << prefix if prefix
+      parts << street if street
+      parts << street_type if street_type && !redundant_street_type
+      parts << suffix if suffix
+      parts.join(' ').strip
+    end
+
+    def street_address_2
+      parts = []
+      parts << unit_prefix if unit_prefix
+      parts << (unit_prefix ? unit : "\# #{unit}") if unit
+      parts.join(' ').strip
+    end
+
+    def full_street_address
+      [line1, line2].reject(&:empty?).join(', ')
+    end
+
+    def to_h
+      instance_variables.each_with_object({}) do |var_name, hash|
+        var_value = instance_variable_get(var_name)
+        hash_name = var_name[1..-1].to_sym
+        hash[hash_name] = var_value
+      end
+    end
+  end
+end

data/lib/street_sweeper/base.rb

@@ -0,0 +1,121 @@
+module StreetSweeper
+  class << self
+    def parse(location, args = {})
+      if Matchers.corner_regexp.match(location)
+        parse_intersection(location, args)
+      else
+        parse_po_address(location, args) || parse_address(location, args) || parse_informal_address(location, args)
+      end
+    end
+
+    def parse_address(address, args = {})
+      matched = Matchers.address_regexp.match(address)
+      return unless matched
+      to_address(match_to_hash(matched), args)
+    end
+
+    def parse_po_address(address, args = {})
+      matched = Matchers.po_address_regexp.match(address)
+      return unless matched
+      to_address(match_to_hash(matched), args)
+    end
+
+    def parse_informal_address(address, args = {})
+      matched = Matchers.informal_address_regexp.match(address)
+      return unless matched
+      to_address(match_to_hash(matched), args)
+    end
+
+    def parse_intersection(intersection, args)
+      matched = Matchers.intersection_regexp.match(intersection)
+      return unless matched
+      hash = match_to_hash(matched)
+
+      streets = Matchers.intersection_regexp.named_captures['street'].map do |pos|
+        matched[pos.to_i]
+      end.select { |v| v }
+
+      hash['street']  = streets[0] if streets[0]
+      hash['street2'] = streets[1] if streets[1]
+
+      street_types = Matchers.intersection_regexp.named_captures['street_type'].map do |pos|
+        matched[pos.to_i]
+      end.select { |v| v }
+
+      hash['street_type']  = street_types[0] if street_types[0]
+      hash['street_type2'] = street_types[1] if street_types[1]
+
+      if hash['street_type'] && (!hash['street_type2'] || (hash['street_type'] == hash['street_type2']))
+        type = hash['street_type'].clone
+        hash['street_type'] = hash['street_type2'] = type if type.gsub!(/s\W*$/i, '') && /\A#{Matchers.street_type_regexp}\z/i =~ type
+      end
+
+      to_address(hash, args)
+    end
+
+    private
+
+    def match_to_hash(matched)
+      hash = {}
+      matched.names.each { |name| hash[name] = matched[name] if matched[name] && !matched[name].strip.empty? }
+      hash
+    end
+
+    def to_address(input, args)
+      # strip off some punctuation and whitespace
+      input.each_value do |string|
+        string.strip!
+        string.gsub!(/[^\w\s\-\#\&]/, '')
+      end
+
+      input['redundant_street_type'] = false
+      if input['street'] && !input['street_type']
+        matched = Matchers.street_regexp.match(input['street'])
+        input['street_type'] = matched['street_type']
+        input['redundant_street_type'] = true
+      end
+
+      ## abbreviate unit prefixes
+      if input['unit_prefix']
+        Constants::UNIT_ABBREVIATIONS.each_pair do |regex, abbr|
+          regex.match(input['unit_prefix']) { |_m| input['unit_prefix'] = abbr }
+        end
+      end
+
+      Constants::NORMALIZE_MAP.each_pair do |key, map|
+        next unless input[key]
+        mapping = map[input[key].downcase]
+        input[key] = mapping if mapping
+      end
+
+      if args[:avoid_redundant_street_type]
+        ['', '1', '2'].each do |suffix|
+          street = input['street'      + suffix]
+          type   = input['street_type' + suffix]
+          next if !street || !type
+
+          type_regexp = Matchers.street_type_matches[type.downcase]
+          input.delete('street_type' + suffix) if type_regexp.match(street)
+        end
+      end
+
+      # attempt to expand directional prefixes on place names
+      if input['city']
+        input['city'].gsub!(/^(#{Matchers.dircode_regexp})\s+(?=\S)/) do |match|
+          Constants::DIRECTION_CODES[match[0].upcase] + ' '
+        end
+      end
+
+      %w[street street_type street2 street_type2 city unit_prefix].each do |k|
+        input[k] = input[k].split.map { |elem| upcase_or_capitalize(elem) }.join(' ') if input[k]
+      end
+
+      StreetSweeper::Address.new(input)
+    end
+
+    def upcase_or_capitalize(elem)
+      return elem.upcase if elem.downcase =~ /^(po|ne|nw|sw|se)$/
+      elem.capitalize
+    end
+  end
+end

data/lib/street_sweeper/constants.rb

@@ -0,0 +1,568 @@
+module StreetSweeper
+  class Constants
+    DIRECTIONAL = {
+      'north'     => 'N',
+      'northeast' => 'NE',
+      'east'      => 'E',
+      'southeast' => 'SE',
+      'south'     => 'S',
+      'southwest' => 'SW',
+      'west'      => 'W',
+      'northwest' => 'NW'
+    }.freeze
+    DIRECTION_CODES = DIRECTIONAL.invert
+
+    STREET_TYPES = {
+      'allee'       => 'aly',
+      'alley'       => 'aly',
+      'ally'        => 'aly',
+      'anex'        => 'anx',
+      'annex'       => 'anx',
+      'annx'        => 'anx',
+      'arcade'      => 'arc',
+      'av'          => 'ave',
+      'aven'        => 'ave',
+      'avenu'       => 'ave',
+      'avenue'      => 'ave',
+      'avn'         => 'ave',
+      'avnue'       => 'ave',
+      'bayoo'       => 'byu',
+      'bayou'       => 'byu',
+      'beach'       => 'bch',
+      'bend'        => 'bnd',
+      'bluf'        => 'blf',
+      'bluff'       => 'blf',
+      'bluffs'      => 'blfs',
+      'bot'         => 'btm',
+      'bottm'       => 'btm',
+      'bottom'      => 'btm',
+      'boul'        => 'blvd',
+      'boulevard'   => 'blvd',
+      'boulv'       => 'blvd',
+      'branch'      => 'br',
+      'brdge'       => 'brg',
+      'bridge'      => 'brg',
+      'brnch'       => 'br',
+      'brook'       => 'brk',
+      'brooks'      => 'brks',
+      'burg'        => 'bg',
+      'burgs'       => 'bgs',
+      'bypa'        => 'byp',
+      'bypas'       => 'byp',
+      'bypass'      => 'byp',
+      'byps'        => 'byp',
+      'camp'        => 'cp',
+      'canyn'       => 'cyn',
+      'canyon'      => 'cyn',
+      'cape'        => 'cpe',
+      'causeway'    => 'cswy',
+      'causway'     => 'cswy',
+      'cen'         => 'ctr',
+      'cent'        => 'ctr',
+      'center'      => 'ctr',
+      'centers'     => 'ctrs',
+      'centr'       => 'ctr',
+      'centre'      => 'ctr',
+      'circ'        => 'cir',
+      'circl'       => 'cir',
+      'circle'      => 'cir',
+      'circles'     => 'cirs',
+      'ck'          => 'crk',
+      'cliff'       => 'clf',
+      'cliffs'      => 'clfs',
+      'club'        => 'clb',
+      'cmp'         => 'cp',
+      'cnter'       => 'ctr',
+      'cntr'        => 'ctr',
+      'cnyn'        => 'cyn',
+      'common'      => 'cmn',
+      'corner'      => 'cor',
+      'corners'     => 'cors',
+      'course'      => 'crse',
+      'court'       => 'ct',
+      'courts'      => 'cts',
+      'cove'        => 'cv',
+      'coves'       => 'cvs',
+      'cr'          => 'crk',
+      'crcl'        => 'cir',
+      'crcle'       => 'cir',
+      'crecent'     => 'cres',
+      'creek'       => 'crk',
+      'crescent'    => 'cres',
+      'cresent'     => 'cres',
+      'crest'       => 'crst',
+      'crossing'    => 'xing',
+      'crossroad'   => 'xrd',
+      'crscnt'      => 'cres',
+      'crsent'      => 'cres',
+      'crsnt'       => 'cres',
+      'crssing'     => 'xing',
+      'crssng'      => 'xing',
+      'crt'         => 'ct',
+      'curve'       => 'curv',
+      'dale'        => 'dl',
+      'dam'         => 'dm',
+      'div'         => 'dv',
+      'divide'      => 'dv',
+      'driv'        => 'dr',
+      'drive'       => 'dr',
+      'drives'      => 'drs',
+      'drv'         => 'dr',
+      'dvd'         => 'dv',
+      'estate'      => 'est',
+      'estates'     => 'ests',
+      'exp'         => 'expy',
+      'expr'        => 'expy',
+      'express'     => 'expy',
+      'expressway'  => 'expy',
+      'expw'        => 'expy',
+      'extension'   => 'ext',
+      'extensions'  => 'exts',
+      'extn'        => 'ext',
+      'extnsn'      => 'ext',
+      'falls'       => 'fls',
+      'ferry'       => 'fry',
+      'field'       => 'fld',
+      'fields'      => 'flds',
+      'flat'        => 'flt',
+      'flats'       => 'flts',
+      'ford'        => 'frd',
+      'fords'       => 'frds',
+      'forest'      => 'frst',
+      'forests'     => 'frst',
+      'forg'        => 'frg',
+      'forge'       => 'frg',
+      'forges'      => 'frgs',
+      'fork'        => 'frk',
+      'forks'       => 'frks',
+      'fort'        => 'ft',
+      'freeway'     => 'fwy',
+      'freewy'      => 'fwy',
+      'frry'        => 'fry',
+      'frt'         => 'ft',
+      'frway'       => 'fwy',
+      'frwy'        => 'fwy',
+      'garden'      => 'gdn',
+      'gardens'     => 'gdns',
+      'gardn'       => 'gdn',
+      'gateway'     => 'gtwy',
+      'gatewy'      => 'gtwy',
+      'gatway'      => 'gtwy',
+      'glen'        => 'gln',
+      'glens'       => 'glns',
+      'grden'       => 'gdn',
+      'grdn'        => 'gdn',
+      'grdns'       => 'gdns',
+      'green'       => 'grn',
+      'greens'      => 'grns',
+      'grov'        => 'grv',
+      'grove'       => 'grv',
+      'groves'      => 'grvs',
+      'gtway'       => 'gtwy',
+      'harb'        => 'hbr',
+      'harbor'      => 'hbr',
+      'harbors'     => 'hbrs',
+      'harbr'       => 'hbr',
+      'haven'       => 'hvn',
+      'havn'        => 'hvn',
+      'height'      => 'hts',
+      'heights'     => 'hts',
+      'hgts'        => 'hts',
+      'highway'     => 'hwy',
+      'highwy'      => 'hwy',
+      'hill'        => 'hl',
+      'hills'       => 'hls',
+      'hiway'       => 'hwy',
+      'hiwy'        => 'hwy',
+      'hllw'        => 'holw',
+      'hollow'      => 'holw',
+      'hollows'     => 'holw',
+      'holws'       => 'holw',
+      'hrbor'       => 'hbr',
+      'ht'          => 'hts',
+      'hway'        => 'hwy',
+      'inlet'       => 'inlt',
+      'island'      => 'is',
+      'islands'     => 'iss',
+      'isles'       => 'isle',
+      'islnd'       => 'is',
+      'islnds'      => 'iss',
+      'jction'      => 'jct',
+      'jctn'        => 'jct',
+      'jctns'       => 'jcts',
+      'junction'    => 'jct',
+      'junctions'   => 'jcts',
+      'junctn'      => 'jct',
+      'juncton'     => 'jct',
+      'key'         => 'ky',
+      'keys'        => 'kys',
+      'knol'        => 'knl',
+      'knoll'       => 'knl',
+      'knolls'      => 'knls',
+      'la'          => 'ln',
+      'lake'        => 'lk',
+      'lakes'       => 'lks',
+      'landing'     => 'lndg',
+      'lane'        => 'ln',
+      'lanes'       => 'ln',
+      'ldge'        => 'ldg',
+      'light'       => 'lgt',
+      'lights'      => 'lgts',
+      'lndng'       => 'lndg',
+      'loaf'        => 'lf',
+      'lock'        => 'lck',
+      'locks'       => 'lcks',
+      'lodg'        => 'ldg',
+      'lodge'       => 'ldg',
+      'loops'       => 'loop',
+      'manor'       => 'mnr',
+      'manors'      => 'mnrs',
+      'meadow'      => 'mdw',
+      'meadows'     => 'mdws',
+      'medows'      => 'mdws',
+      'mill'        => 'ml',
+      'mills'       => 'mls',
+      'mission'     => 'msn',
+      'missn'       => 'msn',
+      'mnt'         => 'mt',
+      'mntain'      => 'mtn',
+      'mntn'        => 'mtn',
+      'mntns'       => 'mtns',
+      'motorway'    => 'mtwy',
+      'mount'       => 'mt',
+      'mountain'    => 'mtn',
+      'mountains'   => 'mtns',
+      'mountin'     => 'mtn',
+      'mssn'        => 'msn',
+      'mtin'        => 'mtn',
+      'neck'        => 'nck',
+      'orchard'     => 'orch',
+      'orchrd'      => 'orch',
+      'overpass'    => 'opas',
+      'ovl'         => 'oval',
+      'parks'       => 'park',
+      'parkway'     => 'pkwy',
+      'parkways'    => 'pkwy',
+      'parkwy'      => 'pkwy',
+      'passage'     => 'psge',
+      'paths'       => 'path',
+      'pikes'       => 'pike',
+      'pine'        => 'pne',
+      'pines'       => 'pnes',
+      'pk'          => 'park',
+      'pkway'       => 'pkwy',
+      'pkwys'       => 'pkwy',
+      'pky'         => 'pkwy',
+      'place'       => 'pl',
+      'plain'       => 'pln',
+      'plaines'     => 'plns',
+      'plains'      => 'plns',
+      'plaza'       => 'plz',
+      'plza'        => 'plz',
+      'point'       => 'pt',
+      'points'      => 'pts',
+      'port'        => 'prt',
+      'ports'       => 'prts',
+      'prairie'     => 'pr',
+      'prarie'      => 'pr',
+      'prk'         => 'park',
+      'prr'         => 'pr',
+      'rad'         => 'radl',
+      'radial'      => 'radl',
+      'radiel'      => 'radl',
+      'ranch'       => 'rnch',
+      'ranches'     => 'rnch',
+      'rapid'       => 'rpd',
+      'rapids'      => 'rpds',
+      'rdge'        => 'rdg',
+      'rest'        => 'rst',
+      'ridge'       => 'rdg',
+      'ridges'      => 'rdgs',
+      'river'       => 'riv',
+      'rivr'        => 'riv',
+      'rnchs'       => 'rnch',
+      'road'        => 'rd',
+      'roads'       => 'rds',
+      'route'       => 'rte',
+      'run'         => 'run',
+      'rvr'         => 'riv',
+      'shoal'       => 'shl',
+      'shoals'      => 'shls',
+      'shoar'       => 'shr',
+      'shoars'      => 'shrs',
+      'shore'       => 'shr',
+      'shores'      => 'shrs',
+      'skyway'      => 'skwy',
+      'spng'        => 'spg',
+      'spngs'       => 'spgs',
+      'spring'      => 'spg',
+      'springs'     => 'spgs',
+      'sprng'       => 'spg',
+      'sprngs'      => 'spgs',
+      'spurs'       => 'spur',
+      'sqr'         => 'sq',
+      'sqre'        => 'sq',
+      'sqrs'        => 'sqs',
+      'squ'         => 'sq',
+      'square'      => 'sq',
+      'squares'     => 'sqs',
+      'station'     => 'sta',
+      'statn'       => 'sta',
+      'stn'         => 'sta',
+      'str'         => 'st',
+      'strav'       => 'stra',
+      'strave'      => 'stra',
+      'straven'     => 'stra',
+      'stravenue'   => 'stra',
+      'stravn'      => 'stra',
+      'stream'      => 'strm',
+      'street'      => 'st',
+      'streets'     => 'sts',
+      'streme'      => 'strm',
+      'strt'        => 'st',
+      'strvn'       => 'stra',
+      'strvnue'     => 'stra',
+      'sumit'       => 'smt',
+      'sumitt'      => 'smt',
+      'summit'      => 'smt',
+      'terr'        => 'ter',
+      'terrace'     => 'ter',
+      'throughway'  => 'trwy',
+      'tpk'         => 'tpke',
+      'tr'          => 'trl',
+      'trace'       => 'trce',
+      'traces'      => 'trce',
+      'track'       => 'trak',
+      'tracks'      => 'trak',
+      'trafficway'  => 'trfy',
+      'trail'       => 'trl',
+      'trails'      => 'trl',
+      'trk'         => 'trak',
+      'trks'        => 'trak',
+      'trls'        => 'trl',
+      'trnpk'       => 'tpke',
+      'trpk'        => 'tpke',
+      'tunel'       => 'tunl',
+      'tunls'       => 'tunl',
+      'tunnel'      => 'tunl',
+      'tunnels'     => 'tunl',
+      'tunnl'       => 'tunl',
+      'turnpike'    => 'tpke',
+      'turnpk'      => 'tpke',
+      'underpass'   => 'upas',
+      'union'       => 'un',
+      'unions'      => 'uns',
+      'valley'      => 'vly',
+      'valleys'     => 'vlys',
+      'vally'       => 'vly',
+      'vdct'        => 'via',
+      'viadct'      => 'via',
+      'viaduct'     => 'via',
+      'view'        => 'vw',
+      'views'       => 'vws',
+      'vill'        => 'vlg',
+      'villag'      => 'vlg',
+      'village'     => 'vlg',
+      'villages'    => 'vlgs',
+      'ville'       => 'vl',
+      'villg'       => 'vlg',
+      'villiage'    => 'vlg',
+      'vist'        => 'vis',
+      'vista'       => 'vis',
+      'vlly'        => 'vly',
+      'vst'         => 'vis',
+      'vsta'        => 'vis',
+      'walks'       => 'walk',
+      'well'        => 'wl',
+      'wells'       => 'wls',
+      'wy'          => 'way'
+    }.freeze
+
+    STREET_TYPES_LIST = {}
+    STREET_TYPES.to_a.each do |item|
+      STREET_TYPES_LIST[item[0]] = true
+      STREET_TYPES_LIST[item[1]] = true
+    end
+
+    NUMERIC_STREET_NAMES = {
+      'first'   => '1st',
+      'second'  => '2nd',
+      'third'   => '3rd',
+      'fourth'  => '4th',
+      'fifth'   => '5th',
+      'sixth'   => '6th',
+      'seventh' => '7th',
+      'eighth'  => '8th',
+      'ninth'   => '9th'
+    }.freeze
+
+    UNIT_ABBREVIATIONS_NUMBERED = {
+      /(?:ap|dep)(?:ar)?t(?:me?nt)?/i => 'Apt',
+      /box/i => 'Box',
+      /bu?i?ldi?n?g/i => 'Bldg',
+      /dep(artmen)?t/i => 'Dept',
+      /flo*r?/i => 'Fl',
+      /ha?nga?r/i => 'Hngr',
+      /lo?t/i => 'Lot',
+      /ro*m/i => 'Rm',
+      /pier/i => 'Pier',
+      /p\W*[om]\W*b(?:ox)?/i => 'PO Box',
+      /slip/i => 'Slip',
+      /spa?ce?/i => 'Spc',
+      /stop/i    => 'Stop',
+      /su?i?te/i => 'Ste',
+      /tra?i?le?r/i => 'Trlr',
+      /uni?t/i => 'Unit'
+    }.freeze
+
+    UNIT_ABBREVIATIONS_UNNUMBERED = {
+      /ba?se?me?n?t/i => 'Bsmt',
+      /fro?nt/i => 'Frnt',
+      /lo?bby/i => 'Lbby',
+      /lowe?r/i => 'Lowr',
+      /off?i?ce?/i => 'Ofc',
+      /pe?n?t?ho?u?s?e?/i => 'PH',
+      /rear/i   => 'Rear',
+      /side/i   => 'Side',
+      /uppe?r/i => 'Uppr'
+    }.freeze
+
+    UNIT_ABBREVIATIONS = UNIT_ABBREVIATIONS_NUMBERED.merge(UNIT_ABBREVIATIONS_UNNUMBERED)
+
+    STATE_CODES = {
+      'alabama' => 'AL',
+      'alaska' => 'AK',
+      'american samoa' => 'AS',
+      'arizona' => 'AZ',
+      'arkansas' => 'AR',
+      'california' => 'CA',
+      'colorado' => 'CO',
+      'connecticut' => 'CT',
+      'delaware' => 'DE',
+      'district of columbia' => 'DC',
+      'federated states of micronesia' => 'FM',
+      'florida' => 'FL',
+      'georgia' => 'GA',
+      'guam' => 'GU',
+      'hawaii' => 'HI',
+      'idaho' => 'ID',
+      'illinois' => 'IL',
+      'indiana' => 'IN',
+      'iowa' => 'IA',
+      'kansas' => 'KS',
+      'kentucky' => 'KY',
+      'louisiana' => 'LA',
+      'maine' => 'ME',
+      'marshall islands' => 'MH',
+      'maryland' => 'MD',
+      'massachusetts' => 'MA',
+      'michigan' => 'MI',
+      'minnesota' => 'MN',
+      'mississippi' => 'MS',
+      'missouri' => 'MO',
+      'montana' => 'MT',
+      'nebraska' => 'NE',
+      'nevada' => 'NV',
+      'new hampshire' => 'NH',
+      'new jersey' => 'NJ',
+      'new mexico' => 'NM',
+      'new york' => 'NY',
+      'north carolina' => 'NC',
+      'north dakota' => 'ND',
+      'northern mariana islands' => 'MP',
+      'ohio' => 'OH',
+      'oklahoma' => 'OK',
+      'oregon' => 'OR',
+      'palau' => 'PW',
+      'pennsylvania' => 'PA',
+      'puerto rico' => 'PR',
+      'rhode island' => 'RI',
+      'south carolina' => 'SC',
+      'south dakota' => 'SD',
+      'tennessee' => 'TN',
+      'texas' => 'TX',
+      'utah' => 'UT',
+      'vermont' => 'VT',
+      'virgin islands' => 'VI',
+      'virginia' => 'VA',
+      'washington' => 'WA',
+      'west virginia' => 'WV',
+      'wisconsin' => 'WI',
+      'wyoming' => 'WY'
+    }.freeze
+
+    STATE_NAMES = STATE_CODES.invert
+
+    STATE_FIPS = {
+      '01' => 'AL',
+      '02' => 'AK',
+      '04' => 'AZ',
+      '05' => 'AR',
+      '06' => 'CA',
+      '08' => 'CO',
+      '09' => 'CT',
+      '10' => 'DE',
+      '11' => 'DC',
+      '12' => 'FL',
+      '13' => 'GA',
+      '15' => 'HI',
+      '16' => 'ID',
+      '17' => 'IL',
+      '18' => 'IN',
+      '19' => 'IA',
+      '20' => 'KS',
+      '21' => 'KY',
+      '22' => 'LA',
+      '23' => 'ME',
+      '24' => 'MD',
+      '25' => 'MA',
+      '26' => 'MI',
+      '27' => 'MN',
+      '28' => 'MS',
+      '29' => 'MO',
+      '30' => 'MT',
+      '31' => 'NE',
+      '32' => 'NV',
+      '33' => 'NH',
+      '34' => 'NJ',
+      '35' => 'NM',
+      '36' => 'NY',
+      '37' => 'NC',
+      '38' => 'ND',
+      '39' => 'OH',
+      '40' => 'OK',
+      '41' => 'OR',
+      '42' => 'PA',
+      '44' => 'RI',
+      '45' => 'SC',
+      '46' => 'SD',
+      '47' => 'TN',
+      '48' => 'TX',
+      '49' => 'UT',
+      '50' => 'VT',
+      '51' => 'VA',
+      '53' => 'WA',
+      '54' => 'WV',
+      '55' => 'WI',
+      '56' => 'WY',
+      '72' => 'PR',
+      '78' => 'VI'
+    }.freeze
+
+    FIPS_STATES = STATE_FIPS.invert
+
+    NORMALIZE_MAP = {
+      'prefix'  => DIRECTIONAL,
+      'prefix1' => DIRECTIONAL,
+      'prefix2' => DIRECTIONAL,
+      'suffix'  => DIRECTIONAL,
+      'suffix1' => DIRECTIONAL,
+      'suffix2' => DIRECTIONAL,
+      'street_type'  => STREET_TYPES,
+      'street_type1' => STREET_TYPES,
+      'street_type2' => STREET_TYPES,
+      'street' => NUMERIC_STREET_NAMES,
+      'state' => STATE_CODES
+    }.freeze
+  end
+end