address_geocoder 0.0.1

data/lib/maps_api/google/requester.rb

@@ -0,0 +1,70 @@
+require 'address_geocoder/requester'
+require 'maps_api/google/url_generator'
+require 'maps_api/google/parser'
+
+module MapsApi
+  module Google
+    # Class for making requests to Google Maps API
+    class Requester < ::AddressGeocoder::Requester
+      # Make a call to Google Maps' Geocoding API
+      # @return (see AddressGeocoder::Requester#make_call)
+      def make_call
+        @url_generator = UrlGenerator.new(address: @address.dup,
+                                          api_key: @api_key,
+                                          language: @language)
+        @url_generator.levels.each do |level_of_search|
+          @url_generator.level = level_of_search
+          call
+          break if success?
+        end
+      end
+
+      # Determines whether the request to Google Maps' Geocoding API was a
+      # success
+      # @return (see AddressGeocoder::Requester#success?)
+      def success?
+        return false unless @result['status'] == 'OK'
+        return false unless @result['results'][0]['address_components'].length > 1
+        true
+      end
+
+      # Check if the certainty level of the response
+      # @note certainty is determined in two ways: first, by ensuring that the
+      #   country was not the only field returned and that it was the correct
+      #   country; second, that the city, state, and postal code were all
+      #   present in the response if they were included in the level of call.
+      def certain?
+        level = @url_generator.level
+        if @parser.just_country?(@result) ||
+           @parser.not_correct_country?(@result)
+          false
+        elsif @parser.city_present?(level) || @parser.state_present?(level) ||
+              @parser.pc_present?(level)
+          false
+        else
+          true
+        end
+      end
+
+      # Return a compacted, flattened array of different address responses.
+      # @return (see AddressGeocoder::Requester#array_result)
+      def array_result
+        [@result['results']].flatten
+      end
+
+      private
+
+      def call
+        attempts = 0
+        begin
+          @result = HTTParty.get(@url_generator.generate_url)
+        rescue
+          sleep(0.5)
+          attempts += 1
+          retry if attempts <= 5
+          connection_error('Could not connect to GoogleAPI')
+        end
+      end
+    end
+  end
+end

data/lib/maps_api/google/url_generator.rb

@@ -0,0 +1,94 @@
+require 'address_geocoder/url_generator'
+
+module MapsApi
+  module Google
+    # Class for generatoring URLs to call Google Maps API
+    class UrlGenerator < ::AddressGeocoder::UrlGenerator
+      # Google's attribute names for our address variables
+      GOOGLE_TITLES = {
+        country: 'country',
+        postal_code: 'postal_code',
+        city: 'locality',
+        state: 'administrative_area'
+      }.freeze
+      # The URL of Google Maps' Geocoding API
+      URL = 'https://maps.googleapis.com/maps/api/geocode/json?'.freeze
+      # Google accepted language codes
+      # @see https://developers.google.com/maps/faq#languagesupport
+      LANGUAGES = ['zh-CN', 'ja', 'es', 'ko', 'ru', 'de', 'fr'].freeze
+      # The call levels to cycle through
+      CYCLE = { base: [1, 5], no_street: [2, 6], no_city: [3, 7],
+                no_state: [4] }.freeze
+
+      # @!attribute level
+      # @return [Integer] the level at which to generate the URL
+      attr_accessor :level
+
+      def initialize(args = {})
+        @level = args[:level]
+        super args
+      end
+
+      # Generates a URL with which to call Google Maps' Geocoding API
+      # @return (see AddressGeocoder::UrlGenerator#generate_url)
+      def generate_url
+        params = prune_address.map { |key, value| add(key, value) }
+        params = params.join.tr('\=', ':').chop
+
+        if ([1, 5] & [@level]).any?
+          street = hash_to_query('address' => @street) + '&'
+        end
+
+        params << "&key=#{@api_key}" unless @api_key.empty?
+
+        language = "&language=#{@language}" if LANGUAGES.include? @language
+
+        "#{URL}#{street}components=#{params}#{language}"
+      end
+
+      # Generates layers of calls to make, starting with a base layer that calls
+      # all valid fields, and removing a layer each call
+      # @return [Array<Integer>] a list of calls to determine what values are
+      #   used in the call to Google Maps' API
+      def levels
+        levels  = []
+        # Assign base levels unless no street
+        levels += CYCLE[:base]      if @address[:street]
+        # Assign levels that don't use street if valid city
+        levels += CYCLE[:no_street] if @address[:city]
+        # Assign levels that don't use street,city if valid state
+        levels += CYCLE[:no_city]   if @address[:state]
+        if @address[:postal_code]
+          # Assign the level that doesn't use street,city,state
+          levels += CYCLE[:no_state]
+        else
+          # Remove all levels that included postal code
+          levels -= [5, 6, 7]
+        end
+        levels.sort
+      end
+
+      private
+
+      # Removes attributes from the address that don't fit with the level
+      # @return [Hash] an address object to add to the call
+      def prune_address
+        address           = (@address.select { |_k, v| v }).to_h
+        address[:country] = address[:country][:alpha2]
+        @street           = address.delete(:street)
+
+        address.delete(:postal_code) if @level > 4
+        address.delete(:city)        if ([3, 4, 7] & [@level]).any?
+        address.delete(:state)       if @level == 4
+        address
+      end
+
+      # Parses a key and value from a hash into a query
+      # @return [String] a query to be used in the URL
+      def add(key, value)
+        str = hash_to_query(GOOGLE_TITLES[key] => value)
+        "#{str}|"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: address_geocoder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Carson Long
+- Wing Leung Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.7
+description: Calls and parses various maps APIs for accurate address validation and
+  geocoding
+email:
+- ctlong.970@gmail.com
+- wingleungchoi@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- address_geocoder.gemspec
+- bin/console
+- bin/setup
+- countries.yaml
+- lib/address_geocoder.rb
+- lib/address_geocoder/client.rb
+- lib/address_geocoder/error.rb
+- lib/address_geocoder/parser.rb
+- lib/address_geocoder/requester.rb
+- lib/address_geocoder/url_generator.rb
+- lib/address_geocoder/version.rb
+- lib/maps_api.rb
+- lib/maps_api/google.rb
+- lib/maps_api/google/client.rb
+- lib/maps_api/google/parser.rb
+- lib/maps_api/google/requester.rb
+- lib/maps_api/google/url_generator.rb
+homepage: https://github.com/ctlong/address_geocoder
+licenses:
+- MIT
+metadata: {}
+post_install_message: Happy mapping!
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Address validation and geocoding
+test_files: []
+has_rdoc: