people_places_things 2.4.1 → 2.5.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 Danny Burkes
+
+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.textile

@@ -65,4 +65,6 @@ h2. Data source
 
 The data that makes up @lib/people_places_things/data/data.yml@ was generated from @lib/people_places_things/data/raw.txt@, which was downloaded from "the US Census website":http://www.census.gov/geo/www/ansi/download.html.
     
-    
+h2. License
+
+SUID is released under the MIT License

data/lib/people_places_things/street_address.rb

@@ -1,6 +1,6 @@
 module PeoplePlacesThings
   class StreetAddress
-    attr_accessor :number, :pre_direction, :name, :suffix, :post_direction, :unit_type, :unit, :raw
+    attr_accessor :number, :pre_direction, :ordinal, :name, :suffix, :post_direction, :unit_type, :unit, :box_number, :raw
   
     def initialize(str)
       self.raw = str
@@ -20,9 +20,15 @@ module PeoplePlacesThings
         if self.unit_type
           self.unit = tokens[-1]
           tokens.slice!(tokens.size - 2, 2)
+          if tokens.size > 0
+            # see if unit_type is specified twice i.e. Suite # 
+            if StreetAddress.find_token(tokens[-1], UNIT_TYPES)
+              tokens.slice!(tokens.size - 1)
+            end
+          end
         end
       end
-    
+        
       # If at least one token remains, check last token for directionality.  If so, set post_direction and delete the token
       #
       if tokens.size > 0
@@ -33,7 +39,7 @@ module PeoplePlacesThings
         end
       end
     
-      # If at least one token remains, check last token for suffix.  If so, self set.suffix and delete the token
+      # If at least one token remains, check last token for suffix.  If so, set suffix and delete the token
       #
       if tokens.size > 0
         self.suffix = StreetAddress.find_token(tokens[-1], SUFFIXES)
@@ -47,8 +53,20 @@ module PeoplePlacesThings
         tokens.shift if self.pre_direction
       end
     
-      # if any tokens remain, set joined remaining tokens as name, otherwise, set name to post_direction, if set, and set post_direction to nil
+      # If at least one token remains, check for ordinal
+      #
+      if tokens.size > 0
+        self.ordinal = tokens.first if StreetAddress.find_token(tokens.first, ORDINALS)
+      end
+      
+      # Check for a PO Box / Rural Route pattern and extract the box_number
       #
+      if tokens.size > 2 && self.number == nil && (tokens.join(' ') =~ PO_BOX_PATTERN || tokens.join(' ') =~ RR_PATTERN)
+        self.box_number = tokens[-1].gsub(/[(,?!\'":.#)]/, '')
+      end
+
+      # if any tokens remain, set joined remaining tokens as name, otherwise, set name to post_direction, if set, and set post_direction to nil
+      #      
       if tokens.size > 0
         self.name = tokens.join(' ')
       else
@@ -59,6 +77,11 @@ module PeoplePlacesThings
       validate_parts
     end
   
+    # check for a valid street address, we assume at least a number or box_number and name is required.
+    def valid?
+      !self.name.nil? && !(self.number.nil? && self.box_number.nil?)
+    end
+    
     def to_s
       parts = []
       parts << self.number if self.number
@@ -70,11 +93,34 @@ module PeoplePlacesThings
       parts << self.unit if self.unit
       parts.join(' ')
     end
+
+    # to_canonical_s 
+    # format the address in a postal service canonical format
+    def to_canonical_s
+      parts = []
+      parts << self.number.upcase if self.number
+      parts << StreetAddress.string_for(self.pre_direction, :short).upcase if self.pre_direction
+      parts << StreetAddress.string_for(StreetAddress.find_token(self.ordinal, ORDINALS), :short).upcase if self.ordinal
+      canonical_name = self.name.gsub(/[(,?!\'":.#)]/, '').gsub(PO_BOX_PATTERN, 'PO BOX').upcase if self.name
+      canonical_name.gsub!(/(rr|r.r.)/i, 'RR') if canonical_name =~ RR_PATTERN 
+      # remove the original ordinal and box from the name, they are output in canonical form separately
+      canonical_name.gsub!(self.ordinal.upcase, '') if self.ordinal
+      canonical_name.gsub!(self.box_number, '') if self.box_number
+      parts << canonical_name.chomp(' ') if canonical_name
+      parts << self.box_number if self.box_number
+      parts << StreetAddress.string_for(self.suffix, :short).upcase if self.suffix
+      parts << StreetAddress.string_for(self.post_direction, :short).upcase if self.post_direction
+      # make all unit type as the canoncial number "#"
+      parts << StreetAddress.string_for(:number, :short).upcase if self.unit_type
+      parts << self.unit.upcase if self.unit
+      parts.delete('')
+      parts.join(' ')      
+    end
   
     def self.string_for(symbol, form)
       raise "Requested unknown form \"#{type}\" for :#{symbol}" if !SUPPORTED_FORMS.include?(form)
     
-      val = DIRECTIONS[symbol] || SUFFIXES[symbol] || UNIT_TYPES[symbol]
+      val = DIRECTIONS[symbol] || SUFFIXES[symbol] || UNIT_TYPES[symbol] || ORDINALS[symbol]
 
       if val
         val = ((val[SUPPORTED_FORMS.index(form)] rescue nil) || (val.first rescue val))
@@ -102,80 +148,267 @@ module PeoplePlacesThings
       nil
     end
   
+    PO_BOX_PATTERN = /(p.o. box|p o box|post office box|po box)/i
+    RR_PATTERN = /(rr|r.r.)\s*(#\d+|\d+)(\s*-\s*|\s*)box(\s*|\s*-\s*)(#\d+|\d+)/i
+    
+    # to_canonical_s uses the short version of each of the following
+    # long version is in position 0
+    # short version is in position 1 
+    
     DIRECTIONS = {
-      :north => %w(north n n.),
+      :north     => %w(north n n.),
       :northeast => %w(northeast ne ne. n.e.),
-      :east => %w(east e e.),
+      :east      => %w(east e e.),
       :southeast => %w(southeast se se. s.e.),
-      :south => %w(south s s.),
+      :south     => %w(south s s.),
       :southwest => %w(southwest sw sw. s.w.),
-      :west => %w(west w w.),
+      :west      => %w(west w w.),
       :northwest => %w(northwest nw nw. n.w.)
+
     }
   
     SUFFIXES = {
-    	:alley => %w(alley al al.),
-    	:avenue => %w(avenue ave ave. av av.),
-    	:beach => %w(beach bch bch.),
-    	:bend => %w(bend),
-    	:boulevard => %w(boulevard blvd blvd. blv blv.),
-    	:center => %w(center ctr ctr.),
-    	:circle => %w(circle cir cir.),
-    	:cliff => %w(cliff clf clf.),
-    	:club => %w(club),
-    	:condo => %w(condo con con.),
-    	:court => %w(court ct ct. cor cor.),
-    	:cove => %w(cove),
-    	:creek => %w(creek crk crk.),
-    	:crossing => %w(crossing xing xing. crs crs.),
-    	:drive => %w(drive dr dr.),
-    	:extension => %w(extension ext ext.),
-    	:freeway => %w(freeway fwy fwy.),
-    	:gardens => %w(gardens gdns gdns.),
-    	:glen => %w(glen gl gl.),
-    	:green => %w(green grn grn.),
-    	:heights => %w(heights hts hts.),
-    	:highway => %w(highway hwy hwy. hgwy hgwy.),
-    	:hill => %w(hill),
-    	:knoll => %w(knoll knl knl.),
-    	:lake => %w(lake),
-    	:lane => %w(lane ln ln.),
-    	:landing => %w(landing lndg lndg.),
-    	:loop => %w(loop),
-    	:meadows => %w(meadows mdws mdws.),
-    	:manor => %w(manor mnr mnr.),
-    	:mountain => %w(mountain mtn mtn. mnt mnt.),
-    	:oaks => %w(oaks),
-    	:oval => %w(oval),
-    	:park => %w(park pk pk. prk prk.),
-    	:parkway => %w(parkway pkwy pkwy. pky pky.),
-    	:pier => %w(pier),
-    	:place => %w(place pl pl.),
-    	:plaza => %w(plaza plz plz.),
-    	:point => %w(point pt pt. pnt pnt.),
-    	:ridge => %w(ridge ri ri.),
-    	:road => %w(road rd rd.),
-    	:row => %w(row),
-    	:run => %w(run),
-    	:springs => %w(springs spgs spgs.),
-    	:square => %w(square sq sq.),
-    	:street => %w(street st st.),
-    	:station => %w(station sta sta.),
-    	:terrace => %w(terrace ter ter. te te.),
-    	:turnpike => %w(turnpike tpke tpke.),
-    	:trace => %w(trace trc trc.),
-    	:trail => %w(trail trl trl. tl tl.),
-    	:valley => %w(valley vly vly.),
-    	:walk => %w(walk),
-    	:way => %w(way)
+    	:alley      => %w(alley aly ally allee al al.),
+    	:anex       => %w(anex anx annex annx anx.),
+    	:arcade     => %w(arcade arc arc.),
+    	:avenue     => %w(avenue ave aven avenu avnue ave. av av.),
+    	:bayou      => %w(bayou byu bayoo byu.),
+    	:beach      => %w(beach bch bch.),
+    	:bend       => %w(bend bnd bnd.),
+    	:bluff      => %w(bluff blf bluf blf.),
+    	:bluffs     => %w(bluffs blfs blfs.),
+    	:bottom     => %w(bottom btm bot bottm btm.),
+    	:boulevard  => %w(boulevard blvd blvd. boul boulv blv blv.),
+    	:branch     => %w(branch br brnch br.),
+    	:bridge     => %w(bridge brg brdge),
+    	:brook      => %w(brook brk brk.),
+    	:brooks     => %w(brooks brks),
+    	:burg       => %w(burg bg),
+    	:burgs      => %w(burgs bgs),
+    	:bypass     => %w(bypass byp bypa bypas byps),
+    	:camp       => %w(camp cp cmp),
+    	:canyon     => %w(canyon cyn canyn cnyn cyn.),
+    	:cape       => %w(cape cpe),
+    	:causeway   => %w(causeway cswy causwa cswy.),
+    	:center     => %w(center ctr cent centr cnter centre cntr ctr.),
+    	:centers    => %w(centers ctrs),
+    	:circle     => %w(circle cir circ circl crcl crcle cir.),
+    	:cliff      => %w(cliff clf clf.),
+    	:cliffs     => %w(cliffs clfs),
+    	:club       => %w(club clb),
+    	:common     => %w(common cmn),
+    	:commons    => %w(commons cmns),
+    	:corner     => %w(corner cor),
+    	:corners    => %w(corners cors),
+    	:condo      => %w(condo con con.),
+    	:court      => %w(court ct ct. cor cor.),
+    	:courts     => %w(courts cts cts.),
+    	:cove       => %w(cove cv),
+    	:coves      => %w(coves cvs),
+    	:creek      => %w(creek crk crk.),
+    	:crescent   => %w(crescent cres crsent crsnt),
+    	:crest      => %w(crest crst),
+    	:crossing   => %w(crossing xing xing. crssng crs crs.),
+    	:crossroad  => %w(crossroad xrd),
+    	:crossroads => %w(crossroads xrds),
+    	:curve      => %w(curve curv),
+    	:dale       => %w(dale dl),
+    	:dam        => %w(dam dm),
+    	:divide     => %w(divide dv div dvd),
+    	:drive      => %w(drive dr driv drv dr.),
+    	:drives     => %w(drives drs),
+    	:estate     => %w(estate est),
+    	:estates    => %w(estates ests),
+    	:expressway => %w(expressway expy exp expr express expw expr),
+    	:extension  => %w(extension ext ext.),
+    	:extensions => %w(extensions exts),
+    	:fall       => %w(fall fall),
+    	:falls      => %w(falls fls),
+    	:ferry      => %w(ferry fry frry),
+    	:field      => %w(field fld),
+    	:fields     => %w(fields flds),
+    	:flat       => %w(flat flt),
+    	:flats      => %w(flats flts),
+    	:ford       => %w(ford, frd),
+    	:fords      => %w(fords frds),
+    	:forest     => %w(forest frst forests),
+    	:forge      => %w(forge frg forg),
+    	:forges     => %w(forges frgs),
+    	:fork       => %w(fork frk),
+    	:forks      => %w(forks frks),
+    	:fort       => %w(fort ft frt),
+    	:freeway    => %w(freeway fwy  freewy frway fwy.),
+    	:garden     => %w(garden gdn gardn grden grdn),
+    	:gardens    => %w(gardens gdns gdns.),
+    	:gateway    => %w(gateway gtwy gatewy gatway gtway),
+    	:glen       => %w(glen gln gl gl.),
+    	:glens      => %w(glens glns),
+    	:green      => %w(green grn grn.),
+    	:greens     => %w(greens grns),
+    	:grove      => %w(grove grv grov),
+    	:groves     => %w(groves grvs),
+    	:harbor     => %w(harbor hbr harb harbr hrbor),
+    	:harbors    => %w(harbors hbrs),
+    	:haven      => %w(haven hvn),
+    	:heights    => %w(heights hts hts.),
+    	:highway    => %w(highway hwy highwy hiway hiwy hway hwy. hgwy hgwy.),
+    	:hill       => %w(hill hl),
+    	:hills      => %w(hills hls),
+    	:hollow     => %w(hollow holw hllw hollows holw holws),
+    	:inlet      => %w(inlet inlt),
+    	:island     => %w(island is islnd),
+    	:islands    => %w(islands iss islnds),
+    	:isle       => %w(isle isle isles),
+    	:junction   => %w(junction jct jction jctn junctn juncton),
+    	:junctions  => %w(junctions jcts jctns),
+    	:key        => %w(key ky),
+    	:keys       => %w(keys kys),
+    	:knoll      => %w(knoll knl knl.),
+    	:knolls     => %w(knolls knls),
+    	:lake       => %w(lake lk),
+    	:lakes      => %w(lakes lks),
+    	:land       => %w(land land),
+    	:landing    => %w(landing lndg lndg.),
+    	:lane       => %w(lane ln ln.),
+    	:light      => %w(light lgt),
+    	:lights     => %w(lights lgts),
+    	:loaf       => %w(loaf lf),
+    	:lock       => %w(lock lck),
+    	:locks      => %w(locks lcks),
+    	:lodge      => %w(lodge ldg ldge lodg),
+    	:loop       => %w(loop loop loops),
+    	:mall       => %w(mall mall),
+    	:manor      => %w(manor mnr),
+    	:manors     => %w(manors mnrs),
+    	:meadow     => %w(meadow mdw),
+    	:meadows    => %w(meadows mdws medows mdws.),
+    	:mews       => %w(mews mews),
+    	:mill       => %w(mill ml),
+    	:mills      => %w(mills mls),
+    	:mission    => %w(mission msn missn),
+    	:motorway   => %w(motorway mtwy),
+    	:mount      => %w(mount mt mnt),
+    	:mountain   => %w(mountain mtn mntn mountin mtn. mnt mnt.),
+    	:mountains  => %w(mountains mtns),
+    	:neck       => %w(neck nck),
+    	:orchard    => %w(orchard orch orchrd),
+    	:oaks       => %w(oaks),
+    	:oval       => %w(oval oval ovl),
+    	:overpass   => %w(overpass opas),
+    	:park       => %w(park park pk. prk prk.),
+    	:parkway    => %w(parkway pkwy pkwy. pky pky.),
+    	:parkways   => %w(parkways pkwy pkwys),
+    	:pass       => %w(pass pass),
+    	:passage    => %w(passage psge),
+    	:path       => %w(path path paths),
+    	:pike       => %w(pike pike pikes),
+    	:pine       => %w(pine pne),
+    	:pines      => %w(pines pnes),
+    	:pier       => %w(pier),
+    	:place      => %w(place pl pl.),
+    	:plain      => %w(plain pln),
+    	:plains     => %w(plains plns),
+    	:plaza      => %w(plaza plz plza plz.),
+    	:point      => %w(point pt pt. pnt pnt.),
+    	:points     => %w(points pts),
+    	:port       => %w(port prt),
+    	:ports      => %w(ports prts),
+    	:prairie    => %w(prairie pr prarie),
+    	:radial     => %w(radial radl rad radiel),
+    	:ramp       => %w(ramp ramp),
+    	:ranch      => %w(ranch rnch ranches rnchs),
+    	:rapid      => %w(rapid rpd),
+    	:rapids     => %w(rapids rpds),
+    	:rest       => %w(rest rst),
+    	:ridge      => %w(ridge rdg rdge ri.),
+    	:ridges     => %w(ridges rdgs),
+    	:river      => %w(river riv rvr),
+    	:road       => %w(road rd rd.),
+    	:roads      => %w(roads rds),
+    	:route      => %w(route rte),
+    	:row        => %w(row row),
+    	:rue        => %w(rue rue),
+    	:run        => %w(run run),
+    	:shoal      => %w(shoal shl),
+    	:shoals     => %w(shoals shls),
+    	:shore      => %w(shore shr shoar),
+    	:skyway     => %w(skyway skwy),
+    	:spring     => %w(spring spg spng sprng),
+    	:springs    => %w(springs spgs spgs.),
+    	:spur       => %w(spur spur spurs),
+    	:square     => %w(square sq sqr sqre squ sq.),
+    	:squares    => %w(squares sqs sqrs),
+    	:station    => %w(station sta sta.),
+    	:stravenue  => %w(stravenue stra strav straven  stravn strvnue),
+    	:stream     => %w(stream strm steme),
+    	:street     => %w(street st strt str st.),
+    	:streets    => %w(streets sts),
+    	:summit     => %w(summit smt sumit sumitt),
+    	:terrace    => %w(terrace ter ter. te te.),
+    	:throughway => %w(throughway trwy),
+    	:trace      => %w(trace trce traces),
+    	:track      => %w(track trak tracks trk trks),
+    	:trafficway => %w(trafficway trfy),  	
+    	:trail      => %w(trail trl trails trls trl. tl tl.),
+    	:trailer    => %w(trailer trlr trlrs),
+    	:tunnel     => %w(tunnel tunl tunls tunnels tunnl),
+    	:turnpike   => %w(turnpike tpke turnpk trnpk tpke.),
+    	:underpass  => %w(underpass upas),
+    	:union      => %w(union un),
+    	:valley     => %w(valley vly vlly vally vly.),
+    	:valleys    => %w(valleys vlys),
+    	:viaduct    => %w(viaduct via vdct viadct),
+    	:view       => %w(view vw),
+    	:views      => %w(views vws),
+    	:village    => %w(village vlg vill villg villiage vlg),
+    	:villages   => %w(villages vlgs),
+    	:ville      => %w(ville vl),
+    	:vista      => %w(vista vs vis vist vst vsta),
+    	:walk       => %w(walk walk walks),
+    	:wall       => %w(wall wall),
+    	:way        => %w(way way wy),
+    	:ways       => %w(ways ways),
+    	:well       => %w(well wl),
+    	:wells      => %w(wells wls)
+
     }
   
     UNIT_TYPES = {
-      :suite => %w(suite ste ste.),
-      :number => %w(number # nbr nbr.),
-      :apartment => %w(apartment apt apt.)
+      :suite      => %w(suite ste ste.),
+      :number     => %w(number # nbr nbr.),
+      :apartment  => %w(apartment apt apt.),
+      :building   => %w(building bldg),
+      :department => %w(department dept),
+      :floor      => %w(floor fl),
+      :room       => %w(room rm),
+      :space      => %w(space spc),
+      :stop       => %w(stop stop),
+      :unit       => %w(unit unit)
+    }
+    
+    ORDINALS = {
+      :first => %w(first 1st),
+      :second => %w(second 2nd),
+      :third => %w(third 3rd),
+      :fourth => %w(fourth 4th forth),
+      :fifth => %w(fifth 5th),
+      :sixth => %w(sixth 6th),
+      :seventh => %w(seventh 7th),
+      :eighth => %w(eighth 8th),
+      :ninth => %w(ninth 9th),
+      :tenth => %w(tenth 10th),
+      :eleventh => %w(eleventh 11th),
+      :twelfth => %w(twelfth 12th),
+      :thirteenth => %w(thirteenth 13th),
+      :fourteenth => %w(fourteenth 14th),
+      :fifteenth => %w(fifteenth 15th),
+      :sixteenth => %w(sixteenth 16th),
+      :seventeenth => %w(seventeenth 17th),
+      :eighteenth => %w(eighteenth 18th),
+      :nineteenth => %w(nineteenth 19th)
     }
   
+    # to_canonical_s format uses the short form
     SUPPORTED_FORMS = [:long, :short]
   end
 end

data/lib/people_places_things/version.rb

@@ -0,0 +1,3 @@
+module PeoplePlacesThings
+  VERSION = "2.5.0"
+end

data/lib/people_places_things.rb

@@ -5,7 +5,4 @@ require 'people_places_things/phone_number'
 require 'people_places_things/zip_code'
 require 'people_places_things/state'
 require 'people_places_things/location'
-
-module PeoplePlacesThings
-  VERSION = "2.4.1"
-end
+require 'people_places_things/version'

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: people_places_things
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 2
-  - 4
-  - 1
-  version: 2.4.1
+  prerelease: 
+  version: 2.5.0
 platform: ruby
 authors: 
 - Danny Burkes
@@ -14,24 +10,42 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-03 00:00:00 -08:00
-default_executable: 
-dependencies: []
-
+date: 2011-10-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.8.6
+  type: :development
+  version_requirements: *id002
 description: Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc.
-email: dburkes@netable.com
+email: 
+- dburkes@netable.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.textile
+extra_rdoc_files: []
+
 files: 
-- .gitignore
 - README.textile
-- Rakefile
-- lib/people_places_things.rb
-- lib/people_places_things/VERSION
+- LICENSE
 - lib/people_places_things/ansi_counties.rb
 - lib/people_places_things/data/data.yml
 - lib/people_places_things/data/process_data.rb
@@ -41,52 +55,35 @@ files:
 - lib/people_places_things/phone_number.rb
 - lib/people_places_things/state.rb
 - lib/people_places_things/street_address.rb
+- lib/people_places_things/version.rb
 - lib/people_places_things/zip_code.rb
-- people_places_things.gemspec
-- spec/ansi_counties_spec.rb
-- spec/helper.rb
-- spec/location_spec.rb
-- spec/person_name_spec.rb
-- spec/phone_number_spec.rb
-- spec/state_spec.rb
-- spec/street_address_spec.rb
-- spec/zip_code_spec.rb
-has_rdoc: true
+- lib/people_places_things.rb
 homepage: http://github.com/dburkes/people_places_things
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc.
-test_files: 
-- spec/ansi_counties_spec.rb
-- spec/helper.rb
-- spec/location_spec.rb
-- spec/person_name_spec.rb
-- spec/phone_number_spec.rb
-- spec/state_spec.rb
-- spec/street_address_spec.rb
-- spec/zip_code_spec.rb
+test_files: []
+

data/.gitignore

@@ -1,3 +0,0 @@
-doc
-*.tmproj
-*.gem

data/Rakefile

@@ -1,42 +0,0 @@
-begin; require 'rubygems'; rescue LoadError; end
-
-require 'rake'
-require 'rake/rdoctask'
-require 'spec/rake/spectask'
-
-desc "Run all specs"
-Spec::Rake::SpecTask.new('specs') do |t|
-  t.libs << 'lib'
-  t.spec_files = FileList['spec/**/*.rb']
-end
-
-Dir['tasks/*.rake'].each{|f| import(f) }
-
-task :default => [:specs]
-
-begin
-  require 'jeweler'
-  require 'lib/people_places_things'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "people_places_things"
-    gemspec.version = PeoplePlacesThings::VERSION
-    gemspec.summary = "Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc."
-    gemspec.email = "dburkes@netable.com"
-    gemspec.homepage = "http://github.com/dburkes/people_places_things"
-    gemspec.description = "Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc."
-    gemspec.authors = ["Danny Burkes"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-namespace :doc do
-  desc "Generate RDoc"
-  Rake::RDocTask.new('people_places_things') { |rdoc|
-    rdoc.rdoc_dir = 'doc'
-    rdoc.options << '--inline-source'
-    # rdoc.rdoc_files.include('README.md')
-    # rdoc.rdoc_files.include('lib/**/*')
-    # rdoc.rdoc_files.exclude('lib/ansi_counties/data/**/*')
-  }
-end

data/lib/people_places_things/VERSION

@@ -1 +0,0 @@
-2.3.0

data/people_places_things.gemspec

@@ -1,70 +0,0 @@
-# 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{people_places_things}
-  s.version = "2.4.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Danny Burkes"]
-  s.date = %q{2010-03-03}
-  s.description = %q{Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc.}
-  s.email = %q{dburkes@netable.com}
-  s.extra_rdoc_files = [
-    "README.textile"
-  ]
-  s.files = [
-    ".gitignore",
-     "README.textile",
-     "Rakefile",
-     "lib/people_places_things.rb",
-     "lib/people_places_things/VERSION",
-     "lib/people_places_things/ansi_counties.rb",
-     "lib/people_places_things/data/data.yml",
-     "lib/people_places_things/data/process_data.rb",
-     "lib/people_places_things/data/raw.txt",
-     "lib/people_places_things/location.rb",
-     "lib/people_places_things/person_name.rb",
-     "lib/people_places_things/phone_number.rb",
-     "lib/people_places_things/state.rb",
-     "lib/people_places_things/street_address.rb",
-     "lib/people_places_things/zip_code.rb",
-     "people_places_things.gemspec",
-     "spec/ansi_counties_spec.rb",
-     "spec/helper.rb",
-     "spec/location_spec.rb",
-     "spec/person_name_spec.rb",
-     "spec/phone_number_spec.rb",
-     "spec/state_spec.rb",
-     "spec/street_address_spec.rb",
-     "spec/zip_code_spec.rb"
-  ]
-  s.homepage = %q{http://github.com/dburkes/people_places_things}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Parsers and formatters for person names, street addresses, city/state/zip, phone numbers, etc.}
-  s.test_files = [
-    "spec/ansi_counties_spec.rb",
-     "spec/helper.rb",
-     "spec/location_spec.rb",
-     "spec/person_name_spec.rb",
-     "spec/phone_number_spec.rb",
-     "spec/state_spec.rb",
-     "spec/street_address_spec.rb",
-     "spec/zip_code_spec.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
-    else
-    end
-  else
-  end
-end
-

data/spec/ansi_counties_spec.rb

@@ -1,27 +0,0 @@
-require 'spec/helper'
-
-describe ANSICounties do
-  it "should find code for valid state and county" do
-    ANSICounties.code_for('ga', 'fulton').should == 13121
-  end
-  
-  it "should find code for valid state and county hash" do
-    ANSICounties.code_for(:state => 'ga', :county => 'fulton').should == 13121
-  end
-  
-  it "should return nil for invalid state and county" do
-    ANSICounties.code_for(:state => 'ga', :county => 'fubar').should == nil
-  end
-  
-  it "should find code for alternate st. form" do
-    ANSICounties.code_for(:state => 'MO', :county => 'saint LOUIS').should == 29510
-  end
-  
-  it "should find data for valid code" do 
-    ANSICounties.data_for(13121).should == { :state => 'GA', :county => 'FULTON' }
-  end
-  
-  it "should return nil for invalid code" do 
-    ANSICounties.data_for(1312111).should == nil
-  end
-end

data/spec/helper.rb

@@ -1,2 +0,0 @@
-require 'lib/people_places_things'
-include PeoplePlacesThings

data/spec/location_spec.rb

@@ -1,56 +0,0 @@
-require 'spec/helper'
-
-describe Location do
-  it "should parse city" do
-    test_location("san francisco", "san francisco", nil, nil)
-  end
-
-  it "should parse city state abbreviation" do
-    test_location("san francisco ca", "san francisco", "CA", nil)
-  end
-
-  it "should parse city state full" do
-    test_location("san francisco california", "san francisco", "CA", nil)
-  end
-
-  it "should parse city comma state" do
-    test_location("san francisco, ca", "san francisco", "CA", nil)
-  end
-  
-  it "should parse city state zip" do
-    test_location("san francisco ca 94114-1212", "san francisco", "CA", '94114-1212')
-  end
-
-  it "should parse city comma state zip" do
-    test_location("san francisco, ca 94114-1212", "san francisco", "CA", '94114-1212')
-  end
-  
-  it "should parse city zip" do
-    test_location("san francisco 94114-1212", "san francisco", nil, '94114-1212')
-  end
-  
-  it "should parse state zip" do
-    test_location("ca 94114-1212", nil, "CA", '94114-1212')
-  end
-  
-  it "should parse state" do
-    test_location("california", nil, "CA", nil)
-  end
-  
-  it "should parse zip" do
-    test_location("94114-1212", nil, nil, '94114-1212')
-  end
-  
-  it "should save raw" do 
-    Location.new('san francisco, ca').raw.should == 'san francisco, ca'
-  end
-  
-  private
-  
-  def test_location(str, city, state, zip)
-    l = Location.new(str)
-    l.city.should == city if l.city
-    l.state.to_s(:abbr).should == state.upcase if l.state
-    l.zip.to_s.should == zip if l.zip
-  end
-end

data/spec/person_name_spec.rb

@@ -1,195 +0,0 @@
-require 'spec/helper'
-
-describe PersonName do
-  it "should parse first_middle_last" do
-    name = PersonName.new "george quincy drake peabody", :first_middle_last
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'peabody'
-  end
-  
-  it "should parse last_first_middle" do
-    name = PersonName.new "peabody george quincy drake", :last_first_middle
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'peabody'
-  end
-  
-  it "should parse last only in first_middle_last format" do
-    name = PersonName.new "peabody", :first_middle_last
-    name.first.should == nil
-    name.middle.should == nil
-    name.last.should == 'peabody'
-  end
-  
-  it "should parse last only in last_first_middle format" do
-    name = PersonName.new "peabody", :last_first_middle
-    name.first.should == nil
-    name.middle.should == nil
-    name.last.should == 'peabody'
-  end
-  
-  it "should parse first middle last suffix" do
-    name = PersonName.new "george f. peabody jr"
-    name.first.should == 'george'
-    name.middle.should == 'f.'
-    name.last.should == 'peabody'
-    name.suffix.should == 'jr'
-  end
-
-  it "should not parse middle initial as suffix" do
-    name = PersonName.new "brown, james v"
-    name.first.should == 'james'
-    name.middle.should == 'v'
-    name.last.should == 'brown'
-    name.suffix.should == nil
-  end
-
-  it "should parse last suffix first middle" do
-    name = PersonName.new "peabody jr george f.", :last_first_middle
-    name.first.should == 'george'
-    name.middle.should == 'f.'
-    name.last.should == 'peabody'
-    name.suffix.should == 'jr'
-  end
-  
-  it "should parse last first middle suffix" do
-    name = PersonName.new "peabody, george f., jr.", :last_first_middle
-    name.first.should == 'george'
-    name.middle.should == 'f.'
-    name.last.should == 'peabody'
-    name.suffix.should == 'jr'
-  end
-
-  it "should default to first_middle_last" do
-    name = PersonName.new "george quincy drake peabody"
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'peabody'
-  end
-  
-  it "should ignore spaces and commas" do
-    name = PersonName.new "  peabody,george  quincy       drake ", :last_first_middle
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'peabody'
-  end
-  
-  it "should strip periods from initials" do 
-    name = PersonName.new "george f. peabody", :first_middle_last
-    name.first.should == 'george'
-    name.middle.should == 'f.'
-    name.middle_i == 'f'
-    name.last.should == 'peabody'
-  end
-  
-  it "should format for :first" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:first).should == 'george'
-  end
-  
-  it "should format for :middle" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:middle).should == 'quincy'
-  end
-  
-  it "should format for :last" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:last).should == 'peabody'
-  end
-  
-  it "should format for :full" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:full).should == 'george quincy peabody'
-  end
-
-  it "should format for :full_reverse" do
-    name = PersonName.new "george quincy peabody jr."
-    name.to_s(:full_reverse).should == 'peabody george quincy jr'
-  end
-  
-  it "should format for :first_space_last" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:first_space_last).should == 'george peabody'
-  end
-  
-  it "should format for :last_space_first" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:last_space_first).should == 'peabody george'
-  end
-  
-  it "should format for :last_comma_first" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:last_comma_first).should == 'peabody,george'
-  end
-  
-  it "should format for :last_comma_space_first" do
-    name = PersonName.new "george quincy peabody"
-    name.to_s(:last_comma_space_first).should == 'peabody, george'
-  end
-  
-  it "should handle missing parts when formatting" do 
-    PersonName.new('peabody').to_s(:last_comma_space_first).should == 'peabody'
-  end
-  
-  it "should respond to individual accessors" do 
-    name = PersonName.new "george quincy peabody"
-    name.first.should == 'george'
-    name.first_i.should == 'g'
-    name.middle.should == 'quincy'
-    name.middle_i.should == 'q'
-    name.last.should == 'peabody'
-    name.last_i.should == 'p'
-  end
-  
-  it "should recognize exact equality" do
-    PersonName.new("george quincy peabody").should be_eql(PersonName.new("george quincy peabody"))
-  end
-
-  it "should ignore case for equality" do
-    PersonName.new("george quincy peabody").should be_eql(PersonName.new("george quincy PEABODY"))
-  end
-  
-  it "should recognize subset equality" do
-    PersonName.new("george quincy peabody").should be_eql(PersonName.new("george peabody"))
-  end
-  
-  it "should parse mc donald for first_middle_last" do
-    name = PersonName.new "george quincy drake mc donald", :first_middle_last
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'mcdonald'
-  end
-  
-  it "should parse mc donald for last_first_middle" do
-    name = PersonName.new "mc donald george quincy drake", :last_first_middle
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'mcdonald'
-  end
-  
-  it "should normalize suffixes" do
-    name = PersonName.new "george quincy peabody jr"
-    name2 = PersonName.new "peabody jr., george quincy", :last_first_middle
-    name.should be_eql(name2)
-  end
-  
-  it "should support auto detect formatting for first_middle_last" do
-    name = PersonName.new "george f. peabody jr"
-    name.first.should == 'george'
-    name.middle.should == 'f.'
-    name.last.should == 'peabody'
-    name.suffix.should == 'jr'
-  end
-  
-  it "should support auto detect formatting for last_first_middle" do
-    name = PersonName.new "peabody, george quincy drake"
-    name.first.should == 'george'
-    name.middle.should == 'quincy drake'
-    name.last.should == 'peabody'
-  end
-  
-  it "should save raw" do
-    PersonName.new("ronald mcdonald").raw.should == 'ronald mcdonald'
-  end
-end

data/spec/phone_number_spec.rb

@@ -1,63 +0,0 @@
-require 'spec/helper'
-
-describe PhoneNumber do
-  it "should parse ten digits" do
-    phone = PhoneNumber.new '4045551212'
-    phone.area_code.should == '404'
-    phone.number.should == '5551212'
-    phone.exchange.should == '555'
-    phone.suffix.should == '1212'
-  end
-
-  it "should parse eleven digits" do
-    phone = PhoneNumber.new '14045551212'
-    phone.area_code.should == '404'
-    phone.number.should == '5551212'
-    phone.exchange.should == '555'
-    phone.suffix.should == '1212'
-  end
-  
-  it "should ignore certain characters" do
-    phone = PhoneNumber.new '1 (404) 555-1212'
-    phone.area_code.should == '404'
-    phone.number.should == '5551212'
-    phone.exchange.should == '555'
-    phone.suffix.should == '1212'
-  end
-  
-  it "should support international format, at least for US numbers, for now" do
-    phone = PhoneNumber.new '+1 404 555-1212'
-    phone.area_code.should == '404'
-    phone.number.should == '5551212'
-    phone.exchange.should == '555'
-    phone.suffix.should == '1212'
-  end
-  
-  it "should throw exception on unsupported parse format" do
-    lambda { PhoneNumber.new('40455512') }.should raise_error
-  end
-  
-  it "should format :full_digits" do
-    PhoneNumber.new('14045551212').to_s(:full_digits).should == '14045551212'
-  end
-
-  it "should format :local_digits" do
-    PhoneNumber.new('14045551212').to_s(:local_digits).should == '5551212'
-  end
-
-  it "should format :full_formatted" do
-    PhoneNumber.new('14045551212').to_s(:full_formatted).should == '1 (404) 555-1212'
-  end
-
-  it "should format :local_formatted" do
-    PhoneNumber.new('14045551212').to_s(:local_formatted).should == '555-1212'
-  end
-
-  it "should throw exception on unsupported to_sformat" do
-    lambda { PhoneNumber.new('14045551212').to_s(:bogus) }.should raise_error
-  end
-  
-  it "should save raw" do
-    PhoneNumber.new('14045551212').raw.should == '14045551212'
-  end
-end

data/spec/state_spec.rb

@@ -1,33 +0,0 @@
-require 'spec/helper'
-
-describe State do
-  it "should parse abbreviation" do
-    state = State.new 'ga'
-    state.sym.should == :ga
-  end
-
-  it "should parse full" do
-    state = State.new 'georgia'
-    state.sym.should == :ga
-  end
-
-  it "should throw exception on unsupported state" do
-    lambda { State.new('foo') }.should raise_error
-  end
-
-  it "should format :abbr" do 
-    State.new('ga').to_s(:abbr).should == 'GA'
-  end
-
-  it "should format :full" do 
-    State.new('ga').to_s(:full).should == 'Georgia'
-  end
-
-  it "should throw exception on unsupported to_s format" do
-    lambda { State.new('ga').to_s(:bogus) }.should raise_error
-  end
-  
-  it "should save raw" do
-    State.new('georgia').raw.should == 'georgia'
-  end
-end

data/spec/street_address_spec.rb

@@ -1,163 +0,0 @@
-require 'spec/helper'
-
-describe StreetAddress do
-  it "should parse number street" do
-    addr = StreetAddress.new "123 Main Street"
-    addr.number.should == '123'
-    addr.name.should == 'Main'
-    addr.suffix.should == :street
-  end
-  
-  it "should parse number with letter" do
-    addr = StreetAddress.new "204-B Main Street"
-    addr.number.should == '204-B'
-    addr.name.should == 'Main'
-    addr.suffix.should == :street
-  end
-  
-  it "should parse pre direction" do 
-    addr = StreetAddress.new "123 E Main Street"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'Main'
-    addr.suffix.should == :street
-  end
-
-  it "should parse post direction" do 
-    addr = StreetAddress.new "123 Main Street NE"
-    addr.number.should == '123'
-    addr.name.should == 'Main'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-  end
-  
-  it "should parse pre and post direction" do 
-    addr = StreetAddress.new "123 E Main Street North"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'Main'
-    addr.suffix.should == :street
-    addr.post_direction.should == :north
-  end
-  
-  it "should parse street names that look like directions" do 
-    addr = StreetAddress.new "123 E E St"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-  end
-
-  it "should parse street names that look like directions, with post directions" do 
-    addr = StreetAddress.new "123 E E St NE"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-  end
-  
-  it "should parse abbreviations" do 
-    addr = StreetAddress.new "123 e. 1st ave"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == '1st'
-    addr.suffix.should == :avenue
-  end
-  
-  it "should parse suites" do
-    addr = StreetAddress.new "123 E E St NE Ste 23"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-    addr.unit_type.should == :suite
-    addr.unit.should == '23'
-  end
-
-  it "should parse apartments" do
-    addr = StreetAddress.new "123 E E St NE Apartment 4"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-    addr.unit_type.should == :apartment
-    addr.unit.should == '4'
-  end
-  
-  it "should parse numbers" do
-    addr = StreetAddress.new '123 E E St NE # 5'
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-    addr.unit_type.should == :number
-    addr.unit.should == '5'
-  end
-  
-  it "should parse no number" do 
-    addr = StreetAddress.new "Westside Highway"
-    addr.number.should == nil
-    addr.name.should == 'Westside'
-    addr.suffix.should == :highway
-  end
-
-  it "should parse directional street with suffix" do 
-    addr = StreetAddress.new "12 north avenue"
-    addr.number.should == '12'
-    addr.name.should == 'north'
-    addr.suffix.should == :avenue
-  end
-  
-  it "should parse directional street without suffix" do 
-    addr = StreetAddress.new "12 north"
-    addr.number.should == '12'
-    addr.name.should == 'north'
-  end
-
-  it "should parse directional street with postdir" do 
-    addr = StreetAddress.new "12 north w"
-    addr.number.should == '12'
-    addr.name.should == 'north'
-    addr.post_direction.should == :west
-  end
-  
-  it "should parse directional street with postdir and unit" do 
-    addr = StreetAddress.new "12 n sw apt. 2"
-    addr.number.should == '12'
-    addr.name.should == 'n'
-    addr.post_direction.should == :southwest
-    addr.unit_type.should == :apartment
-    addr.unit.should == '2'
-  end
-  
-  it "should handle commas" do
-    addr = StreetAddress.new "123 E E St NE, suite 23"
-    addr.number.should == '123'
-    addr.pre_direction.should == :east
-    addr.name.should == 'E'
-    addr.suffix.should == :street
-    addr.post_direction.should == :northeast
-    addr.unit_type.should == :suite
-    addr.unit.should == '23'
-  end
-  
-  it "should support long form" do
-    StreetAddress.string_for(:northwest, :long).should == 'northwest'
-  end
-  
-  it "should support short form" do
-    StreetAddress.string_for(:road, :short).should == 'rd'
-  end
-  
-  it "should support short form when none exists" do
-    StreetAddress.string_for(:oaks, :short).should == StreetAddress.string_for(:oaks, :long)
-  end
-  
-  it "should save raw" do
-    StreetAddress.new('123 Main st.').raw.should == '123 Main st.'
-  end
-end

data/spec/zip_code_spec.rb

@@ -1,31 +0,0 @@
-require 'spec/helper'
-
-describe ZipCode do
-  it "should parse base" do
-    zip = ZipCode.new '30306'
-    zip.base.should == '30306'
-    zip.plus_four.should == nil
-  end
-
-  it "should parse plus four" do
-    zip = ZipCode.new '30306-3522'
-    zip.base.should == '30306'
-    zip.plus_four.should == '3522'
-  end
-  
-  it "should throw exception on unsupported parse format" do
-    lambda { ZipCode.new('303065344') }.should raise_error
-  end
-
-  it "should convert to string" do 
-    ZipCode.new('30306-3522').to_s.should == '30306-3522'
-  end
-
-  it "should throw exception on unsupported to_s format" do
-    lambda { ZipCode.new('30306-3522').to_s(:bogus) }.should raise_error
-  end
-  
-  it "should save raw format" do
-    ZipCode.new('30306-3522').raw.should == '30306-3522'
-  end
-end