auto_location 0.0.1

data/data/states.csv

@@ -0,0 +1 @@
+AL

data/data/zips.csv

@@ -0,0 +1 @@
+35004

data/lib/auto_location/string.rb

@@ -0,0 +1,46 @@
+class String
+  # Add methods to String class
+  def validated_location
+    # If search includes valid zipcode, return zipcode
+    # If zipcode doesn't exist, do city search.
+    # If city doesn't exist, do state search.
+    zipcode(self) || city_perfect_match(self) || city(self) || state(self) || AutoLocation.not_found_location
+  end
+
+  # Check if zipcode exists
+  def zipcode(zipcode)
+    zipcode.scan(/\d{5}/).each do |token|
+      result = AutoLocation.zips[token.to_i]
+      return { location: {zipcode: token, city: result[0], state: result[1]}, type: 'zipcode' } unless result == nil
+    end
+    false
+  end
+
+  def city_perfect_match(city)
+    city = city.upcase
+    result = AutoLocation.cities_hash[city]
+    result == nil ? false : { location: {city: result[0], state: result[1]}, type: 'city' }
+  end
+
+  # Find a city with the search string
+  def city(city)
+    city = city.upcase
+    results = []
+    AutoLocation.cities.find_all do |row|
+      results << row unless city[row[0]] == nil
+    end
+    result = results == [] ? nil : results.max {|a,b| a[1].length <=> b[1].length}
+    result == nil ? false : { location: {city: result[1], state: result[2]}, type: 'city' }
+  end
+
+  # Find a state with the search string
+  def state(state)
+    state = state.upcase
+    # add a white space for easier regex match
+    state.split(/[\s\,]/).each do |token|
+      found_state = AutoLocation.states[token]
+      return { location: found_state, type: 'state' } unless AutoLocation.states[token] == nil
+    end
+    false
+  end
+end

data/lib/auto_location/version.rb

@@ -0,0 +1,3 @@
+module AutoLocation
+  VERSION = "0.0.1"
+end

data/lib/auto_location.rb

@@ -0,0 +1,58 @@
+if RUBY_VERSION.to_f >= 1.9
+  require 'csv'
+else
+  require 'rubygems'
+  require 'faster_csv'
+end
+
+require 'auto_location/string'
+
+module AutoLocation
+  city_file = File.open(File.join(File.dirname(__FILE__), '..', 'data', 'cities.csv'))
+  state_file = File.open(File.join(File.dirname(__FILE__), '..', 'data', 'states.csv'))
+
+  csv_method = lambda{ |x| RUBY_VERSION.to_f >= 1.9 ? CSV.read(x) : FasterCSV.parse(x) }
+  # regular expressions for city: CITY_NAME_PART1.*PART2.*....*STATE.*
+  # ex. San+.*Jose+.*(CA)*.*
+  @cities ||= csv_method.call(city_file).map do |x|
+                [ Regexp.new(((x[2].split(/[\s\,]/).map(&:strip) << ('(' + x[1] + ')')).join('.*') + '*.*').upcase),
+                  x[2],
+                  x[1]
+                ]
+              end
+  @cities_hash ||= Hash[(csv_method.call(city_file)).map do |x|
+                [(x[2] + ', ' + x[1]).upcase, [x[2], x[1]]]
+              end]
+  @zips   ||= Hash[(csv_method.call(city_file)).map do |x|
+                [x[0].to_i, [x[2], x[1]]]
+              end]
+  @states ||= Hash[(csv_method.call(state_file)).map do |x|
+                state = x[0]
+                x[0] = state.upcase
+                x << state
+              end]
+  # default result if zipcode, city, state search all failed
+  @not_found_location ||= {error: "Location Not Found"}.freeze
+
+  class << self
+    def cities
+      @cities
+    end
+
+    def cities_hash
+      @cities_hash
+    end
+
+    def zips
+      @zips
+    end
+
+    def states
+      @states
+    end
+
+    def not_found_location
+      @not_found_location
+    end
+  end
+end

data/lib/tasks/auto_location_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :auto_location do
+#   # Task goes here
+# end

data/spec/lib/auto_location_spec.rb

@@ -0,0 +1,89 @@
+require File.expand_path('../../../lib/auto_location.rb', __FILE__)
+
+describe 'auto location parse location from string' do
+  let(:not_found_location_response) do
+    {error: "Location Not Found"}
+  end
+
+  let(:valid_city_response) do
+    {location: {city: "San Jose", state: "CA"}, type: 'city'}
+  end
+
+  let(:valid_zip_code_response) do
+    {location: {zipcode: '95129', city: "San Jose", state: "CA"}, type: 'zipcode'}
+  end
+
+  let(:valid_state_response_short) do
+    {location: 'CA', type: 'state'}
+  end
+
+  let(:valid_state_response_long) do
+    {location: 'California', type: 'state'}
+  end
+
+  describe 'get zipcode' do
+    it 'when input contains valid zipcode' do
+      expect('string'.zipcode('hello world, San Jose, CA, 95129')).to eq(valid_zip_code_response)
+      expect('string'.zipcode('any random 95129 test here')).to eq(valid_zip_code_response)
+      expect('string'.zipcode('verymessystringthatcontains95129aszipcode')).to eq(valid_zip_code_response)
+    end
+
+    it 'when input does not contain valid zipcode' do
+      expect('string'.zipcode('35000')).to be_falsey
+      expect('string'.zipcode('No valid zip 35000 inside string')).to be_falsey
+      expect('string'.zipcode('350000')).to be_falsey
+    end
+  end
+
+  describe 'get city' do
+    it 'when input contains valid city' do
+      expect('string'.city('1428 downtown south San Jose, San Jose, CA')).to eq(valid_city_response)
+      expect('string'.city('San some text Jose, some textCA')).to eq(valid_city_response)
+      expect('string'.city('sanjoseca')).to eq(valid_city_response)
+      expect('string'.city('some text San some text Jose some text')).to eq(valid_city_response)
+    end
+
+    it 'when input does not contain valid city' do
+      expect('string'.city('1428 San Josa')).to be_falsey
+      expect('string'.city('San Hose, CA')).to be_falsey
+    end
+
+    it 'when input perfectly matches to a city' do
+      expect('string'.city_perfect_match('San Jose, CA')).to eq(valid_city_response)
+    end
+  end
+
+  describe 'get state' do
+    it 'when input contains valid state' do
+      expect('string'.state('ca')).to eq(valid_state_response_short)
+      expect('string'.state('california')).to eq(valid_state_response_long)
+      expect('string'.state('some text cA')).to eq(valid_state_response_short)
+      expect('string'.state('some text California')).to eq(valid_state_response_long)
+    end
+
+    it 'when input does not contain valid state' do
+      expect('string'.state('cc')).to be_falsey
+      expect('string'.state('Calfooooo')).to be_falsey
+      expect('string'.state('some text cC')).to be_falsey
+      expect('string'.state('some text Califoooo')).to be_falsey
+    end
+  end
+
+  describe 'get validated location' do
+    it 'when input contains valid zip' do
+      expect('1428 downtown south San Jose, 95129, San Jose, CA'.validated_location).to eq(valid_zip_code_response)
+    end
+
+    it 'when input contains valid city' do
+      expect('1428 downtown south San Jose, 35000, San Jose, CA'.validated_location).to eq(valid_city_response)
+    end
+
+    it 'when input contains valid state' do
+      expect('1428 random text, 35000, San Josa, CA'.validated_location).to eq(valid_state_response_short)
+    end
+
+    it 'when input contains no valid location' do
+      expect('1428 random text, 35000, San Josa, CC'.validated_location).to eq(not_found_location_response)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+ENV['RAILS_ENV'] = 'test'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: auto_location
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lu Zou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fastercsv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A light-weight gem, get valid US zipcode/city/states from any string.
+email:
+- luxizou.web@gmail.com@move.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- README.rdoc
+- Rakefile
+- auto_location.gemspec
+- data/cities.csv
+- data/states.csv
+- data/zips.csv
+- lib/auto_location.rb
+- lib/auto_location/string.rb
+- lib/auto_location/version.rb
+- lib/tasks/auto_location_tasks.rake
+- spec/lib/auto_location_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/luzou0526/autoLoc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Valid US locations from string
+test_files:
+- spec/lib/auto_location_spec.rb
+- spec/spec_helper.rb