normalic 0.1.0

data/lib/normalic.rb

@@ -0,0 +1,131 @@
+#only handles U.S addresses
+require 'constants'
+
+module Normalic
+  class Address
+
+    attr_accessor :number, :direction, :street, :type, :city, :state, :zipcode
+
+    def initialize(fields={})
+      @number = fields[:number]
+      @direction = fields[:direction]
+      @street = fields[:street]
+      @type = fields[:type]
+      @city = fields[:city]
+      @state = fields[:state]
+      @zipcode = fields[:zipcode]
+    end
+
+    def self.titlize(str)
+      if str
+        str.gsub(/\w+/){|w| w.capitalize}
+      else
+        nil
+      end
+    end
+
+    def [](field_name)
+      begin
+        self.send(field_name.to_s)
+      rescue NoMethodError => e
+        nil
+      end
+    end
+
+    def []=(field_name, value)
+      begin
+        self.send("#{field_name}=", value)
+      rescue NoMethodError => e
+        nil
+      end
+    end
+
+    def to_s
+      #"#{line1},#{" #{city.gsub(/\w+/){|w| w.capitalize}}," if city}#{" #{state.upcase}" if state}#{" " + zipcode if zipcode}".strip
+      "#{line1}#{", #{city}" if city}#{", #{state}" if state}#{" " + zipcode if zipcode}".strip
+      #"#{line1}, #{city}, #{state} #{zipcode}"
+    end
+
+    def line1
+      #"#{number}#{" " + direction.upcase if direction}#{" " + street.gsub(/\w+/){|w| w.capitalize} if street}#{" " + type.capitalize if type}".strip
+      "#{number}#{" " + direction if direction}#{" " + street if street}#{" " + type if type}"
+    end
+
+    #Iteratively take chunks off of the string.
+    def self.parse(address)
+      address.strip!
+      regex = {
+        :unit => /(((\#?\w*)?\W*(su?i?te|p\W*[om]\W*b(?:ox)?|dept|department|ro*m|floor|fl|apt|apartment|unit|box))$)|(\W((su?i?te|p\W*[om]\W*b(?:ox)?|dept|department|ro*m|floor|fl|apt|apartment|unit|box)\W*(\#?\w*)?)\W{0,3}$)/i,
+        :direct => Regexp.new(Directional.keys * '|' + '|' + Directional.values * '\.?|',Regexp::IGNORECASE),
+        :type => Regexp.new('(' + StreetTypes_list * '|' + ')\\W*?$',Regexp::IGNORECASE),
+        :number => /\d+-?\d*/,
+        :fraction => /\d+\/\d+/,
+        :country => /\W+USA$/,
+        :zipcode => /\W+(\d{5}|\d{5}-\d{4})$/,
+        :state => Regexp.new('\W+(' + StateCodes.values * '|' + '|' + StateCodes.keys * '|' + ')$',Regexp::IGNORECASE),
+      }
+      regex[:street] = Regexp.new('((' + regex[:direct].source + ')\\W)?\\W*(.*)\\W*(' + regex[:type].source + ')?', Regexp::IGNORECASE)
+
+      #get rid of USA at the end
+      country_code = address[regex[:country]]
+      address.gsub!(regex[:country], "")
+      zipcode = address[regex[:zipcode]]
+      address.gsub!(regex[:zipcode], "")
+      zipcode.gsub!(/\W/, "") if zipcode
+
+      state = address[regex[:state]]
+      address.gsub!(regex[:state], "")
+      state.gsub!(/(^\W*|\W*$)/, "").downcase! if state
+      state = StateCodes[state] || state
+
+      if ZipCityMap[zipcode]
+        regex[:city] = Regexp.new("\\W+" + ZipCityMap[zipcode] + "$", Regexp::IGNORECASE)
+        regex[:city] = /,.*$/ if !address[regex[:city]]
+        city = ZipCityMap[zipcode]
+      else
+        regex[:city] = /,.*$/
+        city = address[regex[:city]] 
+        city.gsub!(/(^\W*|\W*$)/, "").downcase! if city
+      end
+
+      address.gsub!(regex[:city], "")
+      address.gsub!(regex[:unit], "")
+      address.gsub!(Regexp.new('\W(' + regex[:direct].source + ')\\W{0,3}$', Regexp::IGNORECASE), "")
+
+      type = address[regex[:type]]
+      address.gsub!(regex[:type], "")
+      type.gsub!(/(^\W*|\W*$)/, "").downcase! if type
+      type = StreetTypes[type] || type if type
+
+      if address =~ /(\Wand\W|\W\&\W)/
+        #intersections.  print as is
+        address.gsub!(/(\Wand\W|\W\&\W)/, " and ")
+        arr = ["", address, "", ""]
+      else
+        regex[:address] = Regexp.new('^\W*(' + regex[:number].source + '\\W)?\W*(?:' + regex[:fraction].source + '\W*)?' + regex[:street].source, Regexp::IGNORECASE)
+        arr = regex[:address].match(address).to_a
+      end
+
+      number = arr[1].strip if arr[1]
+      if arr[2] && (!arr[4] || arr[4].empty?)
+        street = arr[2].strip.downcase
+      else
+        dir = Directional[arr[2].strip.downcase] || arr[2].strip.downcase if arr[2]
+        dir.gsub!(/\W/, "") if dir
+      end
+      street = arr[4].strip.downcase if arr[4] && !street
+
+      self.new(
+        {
+          :number => number,
+          :direction => dir ? dir.upcase : nil,
+          :street => titlize(street),
+          :type => titlize(type),
+          :city => titlize(city),
+          :state => state ? state.upcase : nil,
+          :zipcode => zipcode
+        }
+      )
+    end
+  end
+end

data/normalic.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{normalic}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Eric Tang}]
+  s.date = %q{2011-07-31}
+  s.description = %q{Normalize U.S addresses}
+  s.email = %q{eric.x.tang@gmail.com}
+  s.extra_rdoc_files = [%q{README.rdoc}, %q{lib/constants.rb}, %q{lib/normalic.rb}]
+  s.files = [%q{README.rdoc}, %q{Rakefile}, %q{lib/constants.rb}, %q{lib/normalic.rb}, %q{spec/normalic_spec.rb}, %q{Manifest}, %q{normalic.gemspec}]
+  s.homepage = %q{http://github.com/ericxtang/normalic}
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{Normalic}, %q{--main}, %q{README.rdoc}]
+  s.require_paths = [%q{lib}]
+  s.rubyforge_project = %q{normalic}
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Normalize U.S addresses}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/normalic_spec.rb

@@ -0,0 +1,78 @@
+require 'lib/normalic'
+
+describe "Normalic test" do
+
+  it "should parse an address with unit(floor) information" do
+    addr = Normalic::Address.parse("201 Varick St. floor 12th, New York, NY 10014")
+    addr[:number].should == "201"
+    addr[:street].should == "varick"
+    addr[:type].should == "st"
+    addr[:city].should == "new york"
+    addr[:state].should == "ny"
+    addr[:zipcode].should == "10014"
+  end
+
+  it "should parse an address with direction information" do
+    addr = Normalic::Address.parse("167 West 4th Street, New York, NY 10014")
+    addr[:number].should == "167"
+    addr[:street].should == "4th"
+    addr[:direction].should == "w"
+    addr[:type].should == "st"
+    addr[:city].should == "new york"
+    addr[:state].should == "ny"
+    addr[:zipcode].should == "10014"
+  end
+
+  it "should parse an address with incorrect state info" do
+    addr = Normalic::Address.parse("871 Washington Street, New York, NewYork 10014")
+    addr[:number].should == "871"
+    addr[:street].should == "washington"
+    addr[:type].should == "st"
+    addr[:city].should == "new york"
+    addr[:state].should == "ny"
+    addr[:zipcode].should == "10014"
+  end
+
+  it "should parse an address with floor info and without city info" do
+    addr = Normalic::Address.parse("201 Varick St. floor 12th")
+    addr[:number].should == "201"
+    addr[:street].should == "varick"
+    addr[:type].should == "st"
+  end
+
+  it "should parse an address with no city info" do
+    addr = Normalic::Address.parse("871 Washington Street")
+    addr[:number].should == "871"
+    addr[:street].should == "washington"
+    addr[:type].should == "st"
+  end
+
+
+  it "should parse an address with direction info and no city info" do
+    addr = Normalic::Address.parse("871 West Washington Street")
+    addr[:number].should == "871"
+    addr[:street].should == "washington"
+    addr[:direction].should == "w"
+    addr[:type].should == "st"
+  end
+
+  it "should use dot notation" do
+    addr = Normalic::Address.parse("871 West Washington Street")
+    addr.number.should == "871"
+  end
+
+  it "should return nil if a bad field is passed in" do
+    addr = Normalic::Address.parse("871 West Washington Street")
+    addr[:bad_name].should == nil
+  end
+
+  it "should return a line1" do
+    addr = Normalic::Address.parse("871 West Washington Street")
+    addr.line1.should == "871 W Washington St"
+  end
+
+  it "should have a to_s method" do
+    addr = Normalic::Address.parse("167 West 4th Street, New York, NY 10014")
+    addr.to_s.should == "167 W 4th St, New York, NY 10014"
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: normalic
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eric Tang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-31 00:00:00 Z
+dependencies: []
+
+description: Normalize U.S addresses
+email: eric.x.tang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/constants.rb
+- lib/normalic.rb
+files: 
+- README.rdoc
+- Rakefile
+- lib/constants.rb
+- lib/normalic.rb
+- spec/normalic_spec.rb
+- Manifest
+- normalic.gemspec
+homepage: http://github.com/ericxtang/normalic
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Normalic
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: normalic
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Normalize U.S addresses
+test_files: []
+