StreetAddress 1.0.3 → 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3843c6d5bd24be978fa2cca64f03817180094ed4
+  data.tar.gz: 5bd92f6df1dd737c2ba33bd39e46c3fddb7bc92b
+SHA512:
+  metadata.gz: 1aa3a268b475a9f5a124b32ba3d5620329db5e20d7ad2c25acdceca63af2a0458dc0bbb30645b689b09692ab695c9bcd1599c6bdb8c9988d75302261f8d80b8e
+  data.tar.gz: f525201005dd169ebfffe3d036e00ec693f4837c894eb3e3a3c7d063f210c05728a25ff9cbfe7ae419617cd8d564f1a71baa01067c3cbea9292581aeee0d1bfc

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+.swp
+*.log
+.ruby-version
+.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rake'
+end

data/README.md

@@ -0,0 +1,58 @@
+#DESCRIPTION
+  
+Parses one line street addresses and returns a normalized address object.
+
+This is a near direct port of the of the perl module 
+Geo::StreetAddress::US originally written by Schuyler D. Erle.  
+For more information see
+http://search.cpan.org/~sderle/Geo-StreetAddress-US-0.99/
+
+Since the original port in 2007 the two code bases have drifted somewhat.  Any help porting updates would be greatly appreciated.
+
+## Installation
+
+    gem install StreetAddress
+
+then in your code
+
+    require 'street_address'
+
+or from Gemfile
+
+    gem 'StreetAddress', :require => "street_address"
+
+## Basic Usage
+
+    require 'street_address'
+    address = StreetAddress::US.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.to_s # "1600 Pennsylvania Ave, Washington, DC 20500"
+    address.to_s(:line1) # 1600 Pennsylvania Ave
+    StreetAddress::US.parse("1600 Pennsylvania Ave") # nil not a full address
+
+## Informal/Loose Parsing
+
+    address = StreetAddress::US.parse("1600 Pennsylvania Avenue", :informal => true)
+    address.number # 1600
+    address.street # Pennsylvania
+    address.street_type # Ave
+    address.to_s # 1600 Pennsylvania Ave
+
+## Zip+4
+
+    address = StreetAddress::US.parse("5904 Richmond Hwy Ste 340 Alexandria VA 22303-1864")
+    address.postal_code_ext # 1846
+    address = StreetAddress::US.parse("5904 Richmond Hwy Ste 340 Alexandria VA 223031864")
+    address.postal_code_ext # 1846
+
+## License
+The [MIT Licencse](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2014,2016 Derrek Long

data/lib/street_address.rb

@@ -22,7 +22,7 @@
     Hollywood & Vine, Los Angeles, CA, 90028
     Hollywood Blvd and Vine St, Los Angeles, CA, 90028
     Mission Street at Valencia Street, San Francisco, CA, 90028
-    
+
 ==== License
 
     Copyright (c) 2007 Riderway (Derrek Long, Nicholas Schlueter)
@@ -47,24 +47,24 @@
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ==== Notes
-    If parts of the address are omitted from the original string 
+    If parts of the address are omitted from the original string
     the accessor will be nil in StreetAddress::US::Address.
-    
+
     Example:
     address = StreetAddress::US.parse("1600 Pennsylvania Ave, washington, dc")
     assert address.postal_code.nil?
-    
+
 ==== Acknowledgements
-    
+
     This gem is a near direct port of the perl module Geo::StreetAddress::US
     originally written by Schuyler D. Erle.  For more information see
     http://search.cpan.org/~sderle/Geo-StreetAddress-US-0.99/
-    
+
 =end
 
 module StreetAddress
   class US
-    VERSION = '1.0.3'
+    VERSION = '1.0.6'
     DIRECTIONAL = {
       "north" => "N",
       "northeast" => "NE",
@@ -165,6 +165,7 @@ module StreetAddress
       "crssng" => "xing",
       "crt" => "ct",
       "curve" => "curv",
+      "cur" => "curv",
       "dale" => "dl",
       "dam" => "dm",
       "div" => "dv",
@@ -441,9 +442,9 @@ module StreetAddress
       "wells" => "wls",
       "wy" => "way"
     }
-  
+
     STREET_TYPES_LIST = {}
-    STREET_TYPES.to_a.each do |item| 
+    STREET_TYPES.to_a.each do |item|
       STREET_TYPES_LIST[item[0]] = true
       STREET_TYPES_LIST[item[1]] = true
     end
@@ -511,7 +512,7 @@ module StreetAddress
     }
 
     STATE_NAMES = STATE_CODES.invert
-    
+
     STATE_FIPS = {
       "01" => "AL",
       "02" => "AK",
@@ -569,39 +570,47 @@ module StreetAddress
     }
 
     FIPS_STATES = STATE_FIPS.invert
-    
+
     class << self
       attr_accessor(
         :street_type_regexp,
         :number_regexp,
         :fraction_regexp,
         :state_regexp,
+        :city_and_state_regexp,
         :direct_regexp, 
         :zip_regexp,
         :corner_regexp,
         :unit_regexp,
         :street_regexp,
         :place_regexp,
-        :address_regexp
+        :address_regexp,
+        :informal_address_regexp
       )
     end
-      
+
     self.street_type_regexp = STREET_TYPES_LIST.keys.join("|")
     self.number_regexp = '\d+-?\d*'
     self.fraction_regexp = '\d+\/\d+'
     self.state_regexp = STATE_CODES.to_a.join("|").gsub(/ /, "\\s")
-    self.direct_regexp = DIRECTIONAL.keys.join("|") + 
-      "|" + 
-      DIRECTIONAL.values.sort{ |a,b| 
-        b.length <=> a.length 
-      }.map{ |x| 
+    self.city_and_state_regexp = '
+      (?:
+        ([^\d,]+?)\W+
+        (' + state_regexp + ')
+      )'
+
+    self.direct_regexp = DIRECTIONAL.keys.join("|") +
+      "|" +
+      DIRECTIONAL.values.sort{ |a,b|
+        b.length <=> a.length
+      }.map{ |x|
         f = x.gsub(/(\w)/, '\1.')
-        [Regexp::quote(f), Regexp::quote(x)] 
+        [Regexp::quote(f), Regexp::quote(x)]
       }.join("|")
-    self.zip_regexp = '(\d{5})(?:-(\d{4}))?'
+    self.zip_regexp = '(\d{5})(?:-?(\d{4})?)'
     self.corner_regexp = '(?:\band\b|\bat\b|&|\@)'
-    self.unit_regexp = '(?:(su?i?te|p\W*[om]\W*b(?:ox)?|dept|apt|apartment|ro*m|fl|unit|box)\W+|\#\W*)([\w-]+)'
-    self.street_regexp = 
+    self.unit_regexp = '(?:(su?i?te|p\W*[om]\W*b(?:ox)?|dept|apt|apartment|ro*m|fl|unit|box)\W+|(\#)\W*)([\w-]+)'
+    self.street_regexp =
       '(?:
           (?:(' + direct_regexp + ')\W+
           (' + street_type_regexp + ')\b)
@@ -620,51 +629,62 @@ module StreetAddress
             (?:[^\w,]+(' + direct_regexp + ')\b)?
           )
         )'
-    self.place_regexp = 
-      '(?:
-       ([^\d,]+?)\W+
-       ($' + state_regexp + ')\W*
-       )?
+    self.place_regexp =
+      '(?:' + city_and_state_regexp + '\W*)?
        (?:' + zip_regexp + ')?'
-    
+
     self.address_regexp =
-      '\A\W*
+      '\A[^\w\#]*
         (' + number_regexp + ')\W*
         (?:' + fraction_regexp + '\W*)?' +
         street_regexp + '\W+
         (?:' + unit_regexp + '\W+)?' +
         place_regexp +
       '\W*\Z'
-      
+
+    self.informal_address_regexp =
+      '\A\s*
+        (?:' + unit_regexp + '(?:\W+|\Z))?
+        (' + number_regexp + ')\W*
+        (?:' + fraction_regexp + '\W*)?' +
+        street_regexp + '(?:[^\#\w]+|\Z)
+        (?:' + unit_regexp + '(?:\W+|\Z))?' +
+        '(?:' + place_regexp + ')?'
+
 =begin rdoc
 
     parses either an address or intersection and returns an instance of
     StreetAddress::US::Address or nil if the location cannot be parsed
-    
+
+    pass the arguement, :informal => true, to make parsing more lenient
+
 ====example
     StreetAddress::US.parse('1600 Pennsylvania Ave Washington, DC 20006')
     or:
     StreetAddress::US.parse('Hollywood & Vine, Los Angeles, CA')
-    
+    or
+    StreetAddress::US.parse("1600 Pennsylvania Ave", :informal => true)
+
 =end
     class << self
-      def parse(location)
+      def parse(location, args = {})
         if Regexp.new(corner_regexp, Regexp::IGNORECASE).match(location)
-          parse_intersection(location);
-        else 
+          parse_intersection(location)
+        elsif args[:informal]
+          parse_address(location) || parse_informal_address(location)
+        else
           parse_address(location);
         end
       end
-
 =begin rdoc
-    
-    parses only an intersection and returnsan instance of
+
+    parses only an intersection and returns an instance of
     StreetAddress::US::Address or nil if the intersection cannot be parsed
-    
+
 ====example
     address = StreetAddress::US.parse('Hollywood & Vine, Los Angeles, CA')
     assert address.intersection?
-    
+
 =end
       def parse_intersection(inter)
         regex = Regexp.new(
@@ -673,9 +693,9 @@ module StreetAddress
           street_regexp + '\W+' +
           place_regexp + '\W*\Z', Regexp::IGNORECASE + Regexp::EXTENDED
         )
-        
+
         return unless match = regex.match(inter)
-        
+
         normalize_address(
           StreetAddress::US::Address.new(
             :street => match[4] || match[9],
@@ -692,10 +712,10 @@ module StreetAddress
           )
         )
       end
-      
+
 =begin rdoc
 
-    parses only an address and returnsan instance of
+    parses only an address and returns an instance of
     StreetAddress::US::Address or nil if the address cannot be parsed
 
 ====example
@@ -713,18 +733,40 @@ module StreetAddress
            :number => match[1],
            :street => match[5] || match[10] || match[2],
            :street_type => match[6] || match[3],
-           :unit => match[14],
-           :unit_prefix => match[13],
+           :unit => match[15],
+           :unit_prefix => match[13] || match[14],
            :suffix => match[7] || match[12],
            :prefix => match[4],
-           :city => match[15],
-           :state => match[16],
-           :postal_code => match[17],
-           :postal_code_ext => match[18]
+           :city => match[16],
+           :state => match[17],
+           :postal_code => match[18],
+           :postal_code_ext => match[19]
+           )
+        )
+      end
+
+      def parse_informal_address(addr)
+         regex = Regexp.new(informal_address_regexp, Regexp::IGNORECASE + Regexp::EXTENDED)
+
+         return unless match = regex.match(addr)
+
+         normalize_address(
+           StreetAddress::US::Address.new(
+           :number => match[4],
+           :street => match[8] || match[13] || match[5],
+           :street_type => match[9] || match[6],
+           :unit => match[18] || match[3],
+           :unit_prefix => match[16] || match[17] || match[1] || match[2],
+           :suffix => match[10] || match[15],
+           :prefix => match[7],
+           :city => match[19],
+           :state => match[20],
+           :postal_code => match[21],
+           :postal_code_ext => match[22]
            )
         )
       end
-      
+
       private
       def normalize_address(addr)
         addr.state = normalize_state(addr.state) unless addr.state.nil?
@@ -740,7 +782,7 @@ module StreetAddress
         addr.unit_prefix.capitalize! unless addr.unit_prefix.nil?
         return addr
       end
-      
+
       def normalize_state(state)
         if state.length < 3
           state.upcase
@@ -748,13 +790,13 @@ module StreetAddress
           STATE_CODES[state.downcase]
         end
       end
-      
+
       def normalize_street_type(s_type)
         s_type.downcase!
         s_type = STREET_TYPES[s_type] || s_type if STREET_TYPES_LIST[s_type]
         s_type.capitalize
       end
-      
+
       def normalize_directional(dir)
         if dir.length < 3
           dir.upcase
@@ -765,34 +807,34 @@ module StreetAddress
     end
 
 =begin rdoc
-  
-    This is class returned by StreetAddress::US::parse, StreetAddress::US::parse_address 
+
+    This is class returned by StreetAddress::US::parse, StreetAddress::US::parse_address
     and StreetAddress::US::parse_intersection.  If an instance represents an intersection
     the attribute street2 will be populated.
-  
+
 =end
     class Address
       attr_accessor(
-        :number, 
-        :street, 
-        :street_type, 
-        :unit, 
-        :unit_prefix, 
-        :suffix, 
-        :prefix, 
-        :city, 
-        :state, 
-        :postal_code, 
-        :postal_code_ext, 
-        :street2, 
-        :street_type2, 
-        :suffix2, 
+        :number,
+        :street,
+        :street_type,
+        :unit,
+        :unit_prefix,
+        :suffix,
+        :prefix,
+        :city,
+        :state,
+        :postal_code,
+        :postal_code_ext,
+        :street2,
+        :street_type2,
+        :suffix2,
         :prefix2
       )
 
       def initialize(args)
-        args.keys.each do |attrib| 
-          self.send("#{attrib}=", args[attrib]) 
+        args.keys.each do |attrib|
+          self.send("#{attrib}=", args[attrib])
         end
         return
       end
@@ -810,18 +852,31 @@ module StreetAddress
       end
 
       def line1(s = "")
-        s += number
-        s += " " + prefix unless prefix.nil?
-        s += " " + street unless street.nil?
-        s += " " + street_type unless street_type.nil?
-        if( !unit_prefix.nil? && !unit.nil? )
-          s += " " + unit_prefix 
-          s += " " + unit
-        elsif( unit_prefix.nil? && !unit.nil? )
-          s += " #" + unit
+        if intersection?
+          s += prefix + " " unless prefix.nil?
+          s += street
+          s += " " + street_type unless street_type.nil?
+          s += " " + suffix unless suffix.nil?
+          s += " and"
+          s += " " + prefix2 unless prefix2.nil?
+          s += " " + street2
+          s += " " + street_type2 unless street_type2.nil?
+          s += " " + suffix2 unless suffix2.nil?
+        else
+          return if intersection?
+          s += number
+          s += " " + prefix unless prefix.nil?
+          s += " " + street unless street.nil?
+          s += " " + street_type unless street_type.nil?
+          if( !unit_prefix.nil? && !unit.nil? )
+            s += " " + unit_prefix
+            s += " " + unit
+          elsif( unit_prefix.nil? && !unit.nil? )
+            s += " #" + unit
+          end
+
+          return s
         end
-        s += " " + suffix unless suffix.nil?
-        return s
       end
 
       def to_s(format = :default)
@@ -832,7 +887,7 @@ module StreetAddress
         else
           if intersection?
             s += prefix + " " unless prefix.nil?
-            s += street 
+            s += street
             s += " " + street_type unless street_type.nil?
             s += " " + suffix unless suffix.nil?
             s += " and"
@@ -852,7 +907,7 @@ module StreetAddress
           end
         end
         return s
-      end  
+      end
     end
   end
 end

data/street_address.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift 'lib'
+
+require 'street_address'
+
+Gem::Specification.new do |s|
+  s.name = "StreetAddress"
+  s.version = StreetAddress::US::VERSION
+  s.date = Time.now.strftime('%Y-%m-%d')
+  s.summary = "Parse Addresses into substituent parts. This gem includes US only."
+  s.authors = ["Derrek Long"]
+  s.require_paths = ["lib"]
+  s.email = "derreklong@gmail.com"
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test}/*`.split("\n")
+  s.homepage = "https://github.com/derrek/street-address"
+  s.description = <<desc
+StreetAddress::US allows you to send any string to parse and if the string is a US address returns an object of the address broken into it's substituent parts.
+
+A port of Geo::StreetAddress::US by Schuyler D. Erle and Tim Bunce.
+desc
+end

data/test/test_street_address.rb

@@ -10,11 +10,51 @@ class StreetAddressUsTest < Test::Unit::TestCase
     @addr4 = "1005 Gravenstein Hwy N, Sebastopol CA 95472"
     @addr5 = "PO BOX 450, Chicago IL 60657"
     @addr6 = "2730 S Veitch St #207, Arlington, VA 22206"
+    @addr7 = "#42 233 S Wacker Dr 60606"
+    @addr8 = "Apt. 42, 233 S Wacker Dr 60606"
+    @addr9 = "2730 S Veitch St #207"
 
     @int1 = "Hollywood & Vine, Los Angeles, CA"
     @int2 = "Hollywood Blvd and Vine St, Los Angeles, CA"
     @int3 = "Mission Street at Valencia Street, San Francisco, CA"
+  end
+
+  def test_zip_plus_4_with_dash
+    addr = StreetAddress::US.parse("2730 S Veitch St, Arlington, VA 22206-3333")
+    assert_equal "3333", addr.postal_code_ext
+  end
 
+  def test_zip_plus_4_without_dash
+    addr = StreetAddress::US.parse("2730 S Veitch St, Arlington, VA 222064444")
+    assert_equal "4444", addr.postal_code_ext
+  end
+
+  def test_informal_parse_normal_address
+    a = StreetAddress::US.parse("2730 S Veitch St, Arlington, VA 222064444", :informal => true)
+    assert_equal "2730", a.number
+    assert_equal "S", a.prefix
+    assert_equal "Veitch", a.street
+    assert_equal "St", a.street_type
+    assert_equal "Arlington", a.city
+    assert_equal "VA", a.state
+    assert_equal "22206", a.postal_code
+    assert_equal "4444", a.postal_code_ext
+  end
+
+  def test_informal_parse_informal_address
+    a = StreetAddress::US.parse("2730 S Veitch St", :informal => true)
+    assert_equal "2730", a.number
+    assert_equal "S", a.prefix
+    assert_equal "Veitch", a.street
+    assert_equal "St", a.street_type
+  end
+
+  def test_informal_parse_informal_address_trailing_words
+    a = StreetAddress::US.parse("2730 S Veitch St in the south of arlington", :informal => true)
+    assert_equal "2730", a.number
+    assert_equal "S", a.prefix
+    assert_equal "Veitch", a.street
+    assert_equal "St", a.street_type
   end
 
   def test_parse
@@ -58,8 +98,6 @@ class StreetAddressUsTest < Test::Unit::TestCase
     assert_equal addr.city, "Washington"
     assert_equal addr.street2, nil
 
-
- 
     addr = StreetAddress::US.parse(@addr4)
     assert_equal addr.number, "1005"
     assert_equal addr.postal_code, "95472"
@@ -73,14 +111,41 @@ class StreetAddressUsTest < Test::Unit::TestCase
     assert_equal addr.street2, nil
     assert_equal addr.suffix, "N"
 
-  
     addr = StreetAddress::US.parse(@addr5)
     assert_equal addr, nil
-    
-    
+
     addr = StreetAddress::US.parse(@addr6)
     assert_equal("207", addr.unit)
 
+    addr = StreetAddress::US.parse(@addr7, :informal => true)
+    assert_equal addr.number, "233"
+    assert_equal addr.postal_code, "60606"
+    assert_equal addr.prefix, "S"
+    assert_equal addr.state, nil
+    assert_equal addr.street, "Wacker"
+    assert_equal addr.street_type, "Dr"
+    assert_equal addr.unit, "42"
+    assert_equal addr.unit_prefix, "#"
+    assert_equal addr.city, nil
+    assert_equal addr.street2, nil
+    assert_equal addr.suffix, nil
+
+    addr = StreetAddress::US.parse(@addr8, :informal => true)
+    assert_equal addr.number, "233"
+    assert_equal addr.postal_code, "60606"
+    assert_equal addr.prefix, "S"
+    assert_equal addr.state, nil
+    assert_equal addr.street, "Wacker"
+    assert_equal addr.street_type, "Dr"
+    assert_equal addr.unit, "42"
+    assert_equal addr.unit_prefix, "Apt"
+    assert_equal addr.city, nil
+    assert_equal addr.street2, nil
+    assert_equal addr.suffix, nil
+
+    addr = StreetAddress::US.parse(@addr9, :informal => true)
+    assert_equal("207", addr.unit)
+
     addr = StreetAddress::US.parse(@int1)
     assert_equal addr.city, "Los Angeles"
     assert_equal addr.state, "CA"
@@ -111,24 +176,26 @@ class StreetAddressUsTest < Test::Unit::TestCase
     assert_equal addr.intersection?, true
     assert_equal addr.street_type, "St"
     assert_equal addr.street_type2, "St"
-    
-    parseable = ["1600 Pennsylvania Ave Washington DC 20006", 
-          "1600 Pennsylvania Ave #400, Washington, DC, 20006",
-          "1600 Pennsylvania Ave Washington, DC",
-          "1600 Pennsylvania Ave #400 Washington DC",
-          "1600 Pennsylvania Ave, 20006",
-          "1600 Pennsylvania Ave #400, 20006",
-          "1600 Pennsylvania Ave 20006",
-          "1600 Pennsylvania Ave #400 20006",
-          "Hollywood & Vine, Los Angeles, CA",
-          "Hollywood Blvd and Vine St, Los Angeles, CA",
-          "Mission Street at Valencia Street, San Francisco, CA",
-          "Hollywood & Vine, Los Angeles, CA, 90028",
-          "Hollywood Blvd and Vine St, Los Angeles, CA, 90028",
-          "Mission Street at Valencia Street, San Francisco, CA, 90028"]
-    
+
+    parseable = [ 
+      "1600 Pennsylvania Ave Washington DC 20006",
+      "1600 Pennsylvania Ave #400, Washington, DC, 20006",
+      "1600 Pennsylvania Ave Washington, DC",
+      "1600 Pennsylvania Ave #400 Washington DC",
+      "1600 Pennsylvania Ave, 20006",
+      "1600 Pennsylvania Ave #400, 20006",
+      "1600 Pennsylvania Ave 20006",
+      "1600 Pennsylvania Ave #400 20006",
+      "Hollywood & Vine, Los Angeles, CA",
+      "Hollywood Blvd and Vine St, Los Angeles, CA",
+      "Mission Street at Valencia Street, San Francisco, CA",
+      "Hollywood & Vine, Los Angeles, CA, 90028",
+      "Hollywood Blvd and Vine St, Los Angeles, CA, 90028",
+      "Mission Street at Valencia Street, San Francisco, CA, 90028"
+    ]
+
     parseable.each do |location|
-      assert_not_nil(StreetAddress::US.parse(location), location + " was not parse able")
+      assert_not_nil(StreetAddress::US.parse(location), location + " was not parseable")
     end
 
   end

metadata

@@ -1,76 +1,52 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: StreetAddress
-version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 3
-  version: 1.0.3
+version: !ruby/object:Gem::Version
+  version: 1.0.6
 platform: ruby
-authors: 
+authors:
 - Derrek Long
-- Nicholas Schleuter
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-21 00:00:00 -07:00
-default_executable: 
+date: 2014-12-21 00:00:00.000000000 Z
 dependencies: []
-
 description: |
   StreetAddress::US allows you to send any string to parse and if the string is a US address returns an object of the address broken into it's substituent parts.
-  
-  A port of Geo::StreetAddress::US by Schuyler D. Erle and Tim Bunce.
 
+  A port of Geo::StreetAddress::US by Schuyler D. Erle and Tim Bunce.
 email: derreklong@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- README.rdoc
+files:
+- ".gitignore"
+- Gemfile
+- README.md
 - Rakefile
-- LICENSE
 - lib/street_address.rb
+- street_address.gemspec
 - test/test_street_address.rb
-has_rdoc: true
 homepage: https://github.com/derrek/street-address
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Parse Addresses into substituent parts. This gem includes US only.
-test_files: 
-- test/test_street_address.rb
+test_files: []

data/LICENSE

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

data/README.rdoc

@@ -1,35 +0,0 @@
-StreetAddress
-    by Derrek Long
-    https://github.com/derrek/street-address
-
-== DESCRIPTION:
-  
-Parses one line street addresses and returns a normalized address object.
-
-This is a near direct port of the of the perl module 
-Geo::StreetAddress::US originally written by Schuyler D. Erle.  
-For more information see
-http://search.cpan.org/~sderle/Geo-StreetAddress-US-0.99/
-
-== SYNOPSIS:
-
-Parse United States addresses.
-
-=== Basic Usage:
-  require 'street_address'
-  address = StreetAddress::US.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.to_s # "1600 Pennsylvania Ave, Washington, DC 20500"
-  address.to_s(:line1) # 1600 Pennsylvania Ave
-  StreetAddress::US.parse("1600 Pennsylvania Ave") # nil not a full address
-
-=== Gemfile:
-To use from your Gemfile:
-  gem 'StreetAddress', '1.0.2', :require => "street_address"