dburkes-people_places_things 1.3.0 → 2.0.0

data/README.textile

@@ -7,7 +7,7 @@ h2. Using PeoplePlacesThings
 <pre><code>
   require 'people_places_things'
 
-  name = PersonName.parse("george quincy harold peabody jr.")
+  name = PersonName.new("george quincy harold peabody jr.")
   name.first => "george"
   name.first_i => "g"
   name.last => "peabody"
@@ -16,10 +16,10 @@ h2. Using PeoplePlacesThings
   name.to_s(:last_comma_first) => "peabody,george"
   name.to_s(:full) => "george quincy peabody jr."
 
-  name2 = PersonName.parse("peabody jr., george quincy harold", :last_first_middle)
+  name2 = PersonName.new("peabody jr., george quincy harold", :last_first_middle)
   name.eql?(name2) => true
 
-  addr = StreetAddress.parse("204-b ne. 1st ave suite 4")
+  addr = StreetAddress.new("204-b ne. 1st ave suite 4")
   addr.number => "204-b"
   addr.pre_direction => :northeast
   addr.name => "1st"
@@ -32,7 +32,7 @@ h2. Using PeoplePlacesThings
   ANSICounties.code_for(:state => 'ga', :county => 'fulton') => 13121
   ANSICounties.data_for(13121) => { :state => 'GA', :county => 'FULTON' }
   
-  phone = PhoneNumber.parse '14045551212'
+  phone = PhoneNumber.new '14045551212'
   phone.country_code => 1
   phone.area_code => '404'
   phone.number => '5551212'
@@ -40,10 +40,20 @@ h2. Using PeoplePlacesThings
   phone.suffix => '1212'
   phone.to_s => '1 (404) 555-1212'
 
-  zip = ZipCode.parse '30306-3522'
+  zip = ZipCode.new '30306-3522'
   zip.base => '30306'
   zip.plus_four => '3522'
   zip.to_s => '30306-3522'
+  
+  state = State.new 'california'
+  state.sym => :ca
+  state.to_s => 'California'
+  state.to_s(:abbr) => 'CA'
+  
+  location = Location.new 'san francisco, ca 94114-1222'
+  location.city => 'san francisco'
+  location.state.to_s => 'California'
+  location.zip.base => '94114'
 </code></pre>
 
 h2. Data source

data/VERSION

@@ -1 +1 @@
-1.3.0
+2.0.0

data/lib/people_places_things/location/location.rb

@@ -8,12 +8,12 @@ class Location
     
     # try to parse last token as zip
     #
-    self.zip = ZipCode.parse(tokens.last) rescue nil
+    self.zip = ZipCode.new(tokens.last) rescue nil
     tokens = tokens.slice(0..-2) if self.zip
     
     # try to parse last token as state
     #
-    self.state = State.parse(tokens.last) rescue nil
+    self.state = State.new(tokens.last) rescue nil
     tokens = tokens.slice(0..-2) if self.state
     
     # remainder must be city

data/lib/people_places_things/person_name/person_name.rb

@@ -1,140 +1,103 @@
 class PersonName
-  attr_accessor :parts
-  attr_accessor :raw
+  attr_accessor :first, :middle, :last, :suffix, :raw
 
-  def initialize(options={})
-    @parts = options.inject({}) do |parts, (k, v)| 
-      sym_key = (k.to_sym rescue key) || key
-      parts[sym_key] = v if SUPPORTED_PARTS.include?(sym_key)
-      parts
-    end
-  end
-
-  def self.parse(string, fmt = :auto_detect)
+  def initialize(str, fmt = :auto_detect)
     raise "Unsupported Format" if !PARSE_FORMATS.include?(fmt)
     
     if fmt == :auto_detect
-      fmt = string.include?(',') ? :last_first_middle : :first_middle_last
+      fmt = str.include?(',') ? :last_first_middle : :first_middle_last
     end
     
-    args = {}
-
-    parts = string.split(/\s|,/).collect {|p| p.strip}.reject {|p| PersonName.blank?(p) || p == ',' }
+    self.raw = str
+    
+    parts = str.split(/\s|,/).collect {|p| p.strip}.reject {|p| PersonName.blank?(p) || p == ',' }
   
     if parts.size == 1
-      args[:last] = parts.first
+      self.last = parts.first
     else
       case fmt
         when :first_middle_last
           if parts.size > 2 and SUPPORTED_SUFFIXES.detect {|s| s.casecmp(parts.last) == 0}
-            args[:suffix] = normalize_suffix(parts.last)
+            self.suffix = PersonName.normalize_suffix(parts.last)
             parts.delete_at(parts.size - 1)
           end
         
-          args[:first] = parts.first if parts.size > 0
-          args[:last] = parts.last if parts.size > 1
+          self.first = parts.first if parts.size > 0
+          self.last = parts.last if parts.size > 1
         
           if parts.size > 2 && ODD_LAST_NAME_PREFIXES.detect {|s| s.casecmp(parts[-2]) == 0}
-            args[:last] = "#{parts[-2]}#{args[:last]}"
+            self.last = "#{parts[-2]}#{self.last}"
             parts.delete_at(parts.size - 2)
           end
             
-          args[:middle] = parts[1..(parts.size - 2)].join(' ') if parts.size > 2
+          self.middle = parts[1..(parts.size - 2)].join(' ') if parts.size > 2
     
         when :last_first_middle
-          args[:last] = parts.first if parts.size > 0
+          self.last = parts.first if parts.size > 0
         
-          if parts.size > 1 && ODD_LAST_NAME_PREFIXES.detect {|s| s.casecmp(args[:last]) == 0}
-            args[:last] << parts[1]
+          if parts.size > 1 && ODD_LAST_NAME_PREFIXES.detect {|s| s.casecmp(self.last) == 0}
+            self.last << parts[1]
             parts.delete_at(1)
           end
 
           if parts.size > 2 and SUPPORTED_SUFFIXES.detect {|s| s.casecmp(parts[1]) == 0}
-            args[:suffix] = normalize_suffix(parts[1])
+            self.suffix = PersonName.normalize_suffix(parts[1])
             parts.delete_at(1)
           end
 
-          args[:first] = parts[1] if parts.size > 1
-          args[:middle] = parts[2..(parts.size - 1)].join(' ') if parts.size > 2
+          self.first = parts[1] if parts.size > 1
+          self.middle = parts[2..(parts.size - 1)].join(' ') if parts.size > 2
       end
     end
-  
-    n = PersonName.new args
-    n.raw = string
-    n
   end
   
-  def self.format(options, fmt=:full)
-    PersonName.new(options).to_s(fmt)
-  end
-
-  def [](which)
-    @parts[which]
-  end
-
   def to_s(fmt = :full)
     raise "Unsupported Format" if !OUTPUT_FORMATS.include?(fmt)
 
     case fmt
       when :first, :middle, :last
-        @parts[fmt]
+        self.send(fmt)
       
       when :full
-        [@parts[:first], @parts[:middle], @parts[:last], @parts[:suffix]].compact.join(' ')
+        [self.first, self.middle, self.last, self.suffix].compact.join(' ')
         
       when :full_reverse
-        [@parts[:last], @parts[:first], @parts[:middle], @parts[:suffix]].compact.join(' ')
+        [self.last, self.first, self.middle, self.suffix].compact.join(' ')
       
       when :first_space_last
-        [@parts[:first], @parts[:last]].compact.join(' ')
+        [self.first, self.last].compact.join(' ')
       
       when :last_space_first
-        [@parts[:last], @parts[:first]].compact.join(' ')
+        [self.last, self.first].compact.join(' ')
       
       when :last_comma_first
-        [@parts[:last], @parts[:first]].compact.join(',')
+        [self.last, self.first].compact.join(',')
       
       when :last_comma_space_first
-        [(@parts[:first] ? "#{@parts[:last]}," : @parts[:last]), @parts[:first]].compact.join(' ')
+        [(self.first ? "#{self.last}," : self.last), self.first].compact.join(' ')
     end
   end
 
-  def first
-    @parts[:first]
-  end
-
   def first_i
-    first[0,1] rescue nil
-  end
-
-  def middle
-    @parts[:middle]
+    self.first[0,1] rescue nil
   end
 
   def middle_i
-    middle[0,1] rescue nil
-  end
-
-  def last
-    @parts[:last]
+    self.middle[0,1] rescue nil
   end
 
   def last_i
-    last[0,1] rescue nil
-  end
-  
-  def suffix
-    @parts[:suffix]
+    self.last[0,1] rescue nil
   end
   
   def eql?(other, initials_only=false)
     if other.is_a?(PersonName)
-      (self.parts.keys & other.parts.keys).all? do |k|
+      [:first, :middle, :last].all? do |k|
         msg = (k != :last && initials_only) ? "#{k}_i" : k
-        self.send(msg).casecmp(other.send(msg)) == 0
+        me = self.send(msg)
+        them = other.send(msg)
+        me && them ? me.casecmp(them) == 0 : true
       end
-    else
-      false
     end
   end
   
@@ -151,7 +114,6 @@ class PersonName
     suffix.match(/\w+/)[0] rescue suffix
   end
   
-  SUPPORTED_PARTS = [:first,:middle,:last, :suffix]
   SUPPORTED_SUFFIXES = %w(II III IV V JR JR. SR SR.)
   ODD_LAST_NAME_PREFIXES = %w(MC ST ST.)
 end

data/lib/people_places_things/phone_number/phone_number.rb

@@ -1,45 +1,27 @@
 class PhoneNumber
-  @@SUPPORTED_PARTS = [:country_code, :area_code, :number, :exchange, :suffix]
-  @@SUPPORTED_PARTS.each {|attr| attr_accessor attr}
-  attr_accessor :raw
+  attr_accessor :country_code, :area_code, :number, :exchange, :suffix, :raw
   
-  def initialize(parts={})
-    parts.keys.each do |k|
-      send("#{k}=", parts[k]) if @@SUPPORTED_PARTS.include?(k)
-    end
-    
-    raise "Unsupported Format" if !self.exchange || !self.suffix
-  end
-  
-  def self.parse(string)
-    extract = string.strip.match(/^([-+()\d ]+)$/)[0].gsub(/[^\d]/, '') rescue nil
+  def initialize(str)
+    extract = str.strip.match(/^([-+()\d ]+)$/)[0].gsub(/[^\d]/, '') rescue nil
     raise "Unsupported Format" if !extract || extract.length < 10 || extract.length > 11
 
-    parts = {}
-    
     if extract.length == 11
-      parts[:country_code] = extract.slice!(0..0)
+      self.country_code = extract.slice!(0..0)
     else
-      parts[:country_code] = '1'
+      self.country_code = '1'
     end
     
-    raise "Unsupported Format" if parts[:country_code] != '1'
+    raise "Unsupported Format" if self.country_code != '1'
     
-    parts[:area_code] = extract.slice!(0..2)
+    self.area_code = extract.slice!(0..2)
     
-    parts[:number] = extract.dup
+    self.number = extract.dup
 
-    parts[:exchange] = extract.slice!(0..2)
+    self.exchange = extract.slice!(0..2)
     
-    parts[:suffix] = extract
-    
-    ret = PhoneNumber.new parts
-    ret.raw = string
-    ret
-  end
-  
-  def self.format(parts, fmt)
-    PhoneNumber.new(parts).to_s(fmt)
+    self.suffix = extract
+
+    raise "Unsupported Format" if !self.exchange || !self.suffix
   end
   
   def to_s(fmt = :full_formatted)

data/lib/people_places_things/state/state.rb

@@ -1,31 +1,17 @@
 class State
-  attr_accessor :raw
-  attr_accessor :sym
+  attr_accessor :sym, :raw
   
-  def initialize(sym)
-    raise "Unsupported state" if !FORWARD.has_key?(sym)
-    self.sym = sym
-  end
-  
-  def self.parse(string)
-    token = string.strip.downcase
-    sym = nil
+  def initialize(str)
+    self.raw = str
+    token = str.strip.downcase
     
     if FORWARD.has_key?(token.to_sym)
-      sym = token.to_sym
+      self.sym = token.to_sym
     elsif REVERSE.has_key?(token)
-      sym = REVERSE[token]
+      self.sym = REVERSE[token]
     end
     
-    raise "Unsupported Format" if !sym
-
-    ret = State.new sym
-    ret.raw = string
-    ret
-  end
-  
-  def self.format(sym, fmt)
-    State.new(sym).to_s(fmt)
+    raise "Unsupported Format" if !self.sym
   end
   
   def to_s(fmt = :full)

data/lib/people_places_things/street_address/street_address.rb

@@ -1,33 +1,22 @@
 class StreetAddress
-  @@SUPPORTED_PARTS = [:number, :pre_direction, :name, :suffix, :post_direction, :unit_type, :unit]
-  @@SUPPORTED_PARTS.each {|attr| attr_accessor attr}
-  attr_accessor :raw
+  attr_accessor :number, :pre_direction, :name, :suffix, :post_direction, :unit_type, :unit, :raw
   
-  def initialize(parts={})
-    parts.keys.each do |k|
-      send("#{k}=", parts[k]) if @@SUPPORTED_PARTS.include?(k)
-    end
-    
-    validate_parts
-  end
-  
-  def self.parse(string)
-    tokens = string.split(/[\s,]/).select {|s| !s.empty?}
-    parts = {}
+  def initialize(str)
+    tokens = str.split(/[\s,]/).select {|s| !s.empty?}
     
     # Check the first token for leading numericality.  If so, set number to the first token, and delete it
     #
     if tokens.first =~ /(^\d+.*)/
-      parts[:number] = $1
+      self.number = $1
       tokens.shift
     end
     
     # If at least two tokens remain, check next-to-last token as unit type.  If so, set unit_type and unit, and delete the tokens
     #
     if tokens.size > 1 
-      parts[:unit_type] = find_token(tokens[-2], UNIT_TYPES)
-      if parts[:unit_type]
-        parts[:unit] = tokens[-1]
+      self.unit_type = StreetAddress.find_token(tokens[-2], UNIT_TYPES)
+      if self.unit_type
+        self.unit = tokens[-1]
         tokens.slice!(tokens.size - 2, 2)
       end
     end
@@ -35,8 +24,8 @@ class StreetAddress
     # If at least one token remains, check last token for directionality.  If so, set post_direction and delete the token
     #
     if tokens.size > 0
-      parts[:post_direction] = find_token(tokens[-1], DIRECTIONS)
-      if parts[:post_direction]
+      self.post_direction = StreetAddress.find_token(tokens[-1], DIRECTIONS)
+      if self.post_direction
         post_direction_token = tokens[-1]
         tokens.slice!(tokens.size - 1)
       end
@@ -45,33 +34,27 @@ class StreetAddress
     # If at least one token remains, check last token for suffix.  If so, self set.suffix and delete the token
     #
     if tokens.size > 0
-      parts[:suffix] = find_token(tokens[-1], SUFFIXES)
-      tokens.slice!(tokens.size - 1) if parts[:suffix]
+      self.suffix = StreetAddress.find_token(tokens[-1], SUFFIXES)
+      tokens.slice!(tokens.size - 1) if self.suffix
     end
     
     # If at least two tokens remain, check first for directionality. If so, set pre_direction and delete token
     #
     if tokens.size > 1
-      parts[:pre_direction] = find_token(tokens.first, DIRECTIONS)
-      tokens.shift if parts[:pre_direction]
+      self.pre_direction = StreetAddress.find_token(tokens.first, DIRECTIONS)
+      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 tokens.size > 0
-      parts[:name] = tokens.join(' ')
+      self.name = tokens.join(' ')
     else
-      parts[:name] = post_direction_token
-      parts[:post_direction] = nil
+      self.name = post_direction_token
+      self.post_direction = nil
     end
     
-    ret = StreetAddress.new parts
-    ret.raw = string
-    ret
-  end
-  
-  def self.format(parts)
-    StreetAddress.new(parts).to_s
+    validate_parts
   end
   
   def to_s

data/lib/people_places_things/zip_code/zip_code.rb

@@ -1,42 +1,15 @@
 class ZipCode
-  @@SUPPORTED_PARTS = [:base, :plus_four]
-  @@SUPPORTED_PARTS.each {|attr| attr_accessor attr}
-  attr_accessor :raw
+  attr_accessor :base, :plus_four, :raw
   
-  def initialize(parts={})
-    parts.keys.each do |k|
-      send("#{k}=", parts[k]) if @@SUPPORTED_PARTS.include?(k)
-    end
-  end
-  
-  def self.parse(string)
-    tokens = string.strip.match(/^(\d{5})(-\d{4})?$/)[0].split('-') rescue nil
+  def initialize(str)
+    tokens = str.strip.match(/^(\d{5})(-\d{4})?$/)[0].split('-') rescue nil
     raise "Unsupported Format" if !tokens
 
-    parts = {}
-    parts[:base] = tokens.first
-    parts[:plus_four] = tokens[1] rescue nil
-    
-    ret = ZipCode.new parts
-    ret.raw = string
-    ret
-  end
-  
-  def self.format(parts, fmt)
-    ZipCode.new(parts).to_s(fmt)
+    self.base = tokens.first
+    self.plus_four = tokens[1] rescue nil
   end
   
-  def to_s(fmt = :plus_four)
-    raise "Unsupported Format" if !OUTPUT_FORMATS.include?(fmt)
-
-    case fmt
-      when :base
-        self.base
-        
-      when :plus_four
-        [self.base, self.plus_four].compact.join('-')
-    end
+  def to_s
+    [self.base, self.plus_four].compact.join('-')
   end
-  
-  OUTPUT_FORMATS = [:base, :plus_four]
 end

data/people_places_things.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{people_places_things}
-  s.version = "1.3.0"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Danny Burkes"]

data/spec/person_name_spec.rb

@@ -2,35 +2,35 @@ require 'spec/helper'
 
 describe PersonName do
   it "should parse first_middle_last" do
-    name = PersonName.parse "george quincy drake peabody", :first_middle_last
+    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.parse "peabody george quincy drake", :last_first_middle
+    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.parse "peabody", :first_middle_last
+    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.parse "peabody", :last_first_middle
+    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.parse "george f. peabody jr"
+    name = PersonName.new "george f. peabody jr"
     name.first.should == 'george'
     name.middle.should == 'f.'
     name.last.should == 'peabody'
@@ -38,7 +38,7 @@ describe PersonName do
   end
 
   it "should parse last suffix first middle" do
-    name = PersonName.parse "peabody jr george f.", :last_first_middle
+    name = PersonName.new "peabody jr george f.", :last_first_middle
     name.first.should == 'george'
     name.middle.should == 'f.'
     name.last.should == 'peabody'
@@ -46,21 +46,21 @@ describe PersonName do
   end
   
   it "should default to first_middle_last" do
-    name = PersonName.parse "george quincy drake peabody"
+    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.parse "  peabody,george  quincy       drake ", :last_first_middle
+    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.parse "george f. peabody", :first_middle_last
+    name = PersonName.new "george f. peabody", :first_middle_last
     name.first.should == 'george'
     name.middle.should == 'f.'
     name.middle_i == 'f'
@@ -68,63 +68,56 @@ describe PersonName do
   end
   
   it "should format for :first" do
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
+    name = PersonName.new "george quincy peabody"
     name.to_s(:first).should == 'george'
   end
   
   it "should format for :middle" do
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
+    name = PersonName.new "george quincy peabody"
     name.to_s(:middle).should == 'quincy'
   end
   
   it "should format for :last" do
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
+    name = PersonName.new "george quincy peabody"
     name.to_s(:last).should == 'peabody'
   end
   
   it "should format for :full" do
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
+    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 :first => 'george', :middle => 'quincy', :last => 'peabody', :suffix => 'jr.'
-    name.to_s(:full_reverse).should == 'peabody george quincy jr.'
+    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 :first => 'george', :middle => 'quincy', :last => 'peabody'
+    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 :first => 'george', :middle => 'quincy', :last => 'peabody'
+    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 :first => 'george', :middle => 'quincy', :last => 'peabody'
+    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 :first => 'george', :middle => 'quincy', :last => 'peabody'
+    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({ :last => 'peabody' }).to_s(:last_comma_space_first).should == 'peabody'
-  end
-  
-  it "should respond to index method" do
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
-    name[:first].should == 'george'
-    name[:middle].should == 'quincy'
-    name[:last].should == 'peabody'
+    PersonName.new('peabody').to_s(:last_comma_space_first).should == 'peabody'
   end
   
   it "should respond to individual accessors" do 
-    name = PersonName.new :first => 'george', :middle => 'quincy', :last => 'peabody'
+    name = PersonName.new "george quincy peabody"
     name.first.should == 'george'
     name.first_i.should == 'g'
     name.middle.should == 'quincy'
@@ -134,39 +127,39 @@ describe PersonName do
   end
   
   it "should recognize exact equality" do
-    PersonName.parse("george quincy peabody").should be_eql(PersonName.parse("george quincy peabody"))
+    PersonName.new("george quincy peabody").should be_eql(PersonName.new("george quincy peabody"))
   end
 
   it "should ignore case for equality" do
-    PersonName.parse("george quincy peabody").should be_eql(PersonName.parse("george quincy PEABODY"))
+    PersonName.new("george quincy peabody").should be_eql(PersonName.new("george quincy PEABODY"))
   end
   
   it "should recognize subset equality" do
-    PersonName.parse("george quincy peabody").should be_eql(PersonName.parse("george peabody"))
+    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.parse "george quincy drake mc donald", :first_middle_last
+    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.parse "mc donald george quincy drake", :last_first_middle
+    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.parse "george quincy peabody jr"
-    name2 = PersonName.parse "peabody jr., george quincy", :last_first_middle
+    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.parse "george f. peabody jr"
+    name = PersonName.new "george f. peabody jr"
     name.first.should == 'george'
     name.middle.should == 'f.'
     name.last.should == 'peabody'
@@ -174,7 +167,7 @@ describe PersonName do
   end
   
   it "should support auto detect formatting for last_first_middle" do
-    name = PersonName.parse "peabody, george quincy drake"
+    name = PersonName.new "peabody, george quincy drake"
     name.first.should == 'george'
     name.middle.should == 'quincy drake'
     name.last.should == 'peabody'

data/spec/phone_number_spec.rb

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

data/spec/state_spec.rb

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

data/spec/street_address_spec.rb

@@ -2,21 +2,21 @@ require 'spec/helper'
 
 describe StreetAddress do
   it "should parse number street" do
-    addr = StreetAddress.parse "123 Main Street"
+    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.parse "204-B Main Street"
+    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.parse "123 E Main Street"
+    addr = StreetAddress.new "123 E Main Street"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'Main'
@@ -24,7 +24,7 @@ describe StreetAddress do
   end
 
   it "should parse post direction" do 
-    addr = StreetAddress.parse "123 Main Street NE"
+    addr = StreetAddress.new "123 Main Street NE"
     addr.number.should == '123'
     addr.name.should == 'Main'
     addr.suffix.should == :street
@@ -32,7 +32,7 @@ describe StreetAddress do
   end
   
   it "should parse pre and post direction" do 
-    addr = StreetAddress.parse "123 E Main Street North"
+    addr = StreetAddress.new "123 E Main Street North"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'Main'
@@ -41,7 +41,7 @@ describe StreetAddress do
   end
   
   it "should parse street names that look like directions" do 
-    addr = StreetAddress.parse "123 E E St"
+    addr = StreetAddress.new "123 E E St"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'
@@ -49,7 +49,7 @@ describe StreetAddress do
   end
 
   it "should parse street names that look like directions, with post directions" do 
-    addr = StreetAddress.parse "123 E E St NE"
+    addr = StreetAddress.new "123 E E St NE"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'
@@ -58,7 +58,7 @@ describe StreetAddress do
   end
   
   it "should parse abbreviations" do 
-    addr = StreetAddress.parse "123 e. 1st ave"
+    addr = StreetAddress.new "123 e. 1st ave"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == '1st'
@@ -66,7 +66,7 @@ describe StreetAddress do
   end
   
   it "should parse suites" do
-    addr = StreetAddress.parse "123 E E St NE Ste 23"
+    addr = StreetAddress.new "123 E E St NE Ste 23"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'
@@ -77,7 +77,7 @@ describe StreetAddress do
   end
 
   it "should parse apartments" do
-    addr = StreetAddress.parse "123 E E St NE Apartment 4"
+    addr = StreetAddress.new "123 E E St NE Apartment 4"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'
@@ -88,7 +88,7 @@ describe StreetAddress do
   end
   
   it "should parse numbers" do
-    addr = StreetAddress.parse '123 E E St NE # 5'
+    addr = StreetAddress.new '123 E E St NE # 5'
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'
@@ -99,34 +99,34 @@ describe StreetAddress do
   end
   
   it "should parse no number" do 
-    addr = StreetAddress.parse "Westside Highway"
+    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.parse "12 north avenue"
+    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.parse "12 north"
+    addr = StreetAddress.new "12 north"
     addr.number.should == '12'
     addr.name.should == 'north'
   end
 
   it "should parse directional street with postdir" do 
-    addr = StreetAddress.parse "12 north w"
+    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.parse "12 n sw apt. 2"
+    addr = StreetAddress.new "12 n sw apt. 2"
     addr.number.should == '12'
     addr.name.should == 'n'
     addr.post_direction.should == :southwest
@@ -135,7 +135,7 @@ describe StreetAddress do
   end
   
   it "should handle commas" do
-    addr = StreetAddress.parse "123 E E St NE, suite 23"
+    addr = StreetAddress.new "123 E E St NE, suite 23"
     addr.number.should == '123'
     addr.pre_direction.should == :east
     addr.name.should == 'E'

data/spec/zip_code_spec.rb

@@ -2,30 +2,26 @@ require 'spec/helper'
 
 describe ZipCode do
   it "should parse base" do
-    zip = ZipCode.parse '30306'
+    zip = ZipCode.new '30306'
     zip.base.should == '30306'
     zip.plus_four.should == nil
   end
 
   it "should parse plus four" do
-    zip = ZipCode.parse '30306-3522'
+    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.parse('303065344') }.should raise_error
-  end
-
-  it "should format :base" do 
-    ZipCode.parse('30306-3522').to_s(:base).should == '30306'
+    lambda { ZipCode.new('303065344') }.should raise_error
   end
 
-  it "should format :plus_four" do 
-    ZipCode.parse('30306-3522').to_s(:plus_four).should == '30306-3522'
+  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.parse('30306-3522').to_s(:bogus) }.should raise_error
+    lambda { ZipCode.new('30306-3522').to_s(:bogus) }.should raise_error
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dburkes-people_places_things
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Danny Burkes