geocoder 1.2.9 → 1.3.0

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -0,0 +1,65 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geoportail_lu"
+
+module Geocoder
+  module Lookup
+    class GeoportailLu < Base
+
+      def name
+        "Geoportail.lu"
+      end
+
+      def query_url(query)
+        url_base_path(query) + url_query_string(query)
+      end
+
+      private
+
+      def url_base_path(query)
+        query.reverse_geocode? ? reverse_geocode_url_base_path : search_url_base_path
+      end
+
+      def search_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/search?"
+      end
+
+      def reverse_geocode_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/reverseGeocode?"
+      end
+
+      def query_url_geoportail_lu_params(query)
+        query.reverse_geocode? ? reverse_geocode_params(query) : search_params(query)
+      end
+
+      def search_params(query)
+        {
+            queryString: query.sanitized_text
+        }
+      end
+
+      def reverse_geocode_params(query)
+        lat_lon = query.coordinates
+        {
+            lat: lat_lon.first,
+            lon: lat_lon.last
+        }
+      end
+
+      def query_url_params(query)
+        query_url_geoportail_lu_params(query).merge(super)
+      end
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+        if doc['success'] == true
+          result = doc['results']
+        else
+          result = []
+          raise_error(Geocoder::Error) ||
+              warn("Geportail.lu Geocoding API error")
+        end
+        result
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google.rb

@@ -12,6 +12,15 @@ module Geocoder::Lookup
       "http://maps.google.com/maps?q=#{coordinates.join(',')}"
     end
 
+    def supported_protocols
+      # Google requires HTTPS if an API key is used.
+      if configuration.api_key
+        [:https]
+      else
+        [:http, :https]
+      end
+    end
+
     def query_url(query)
       "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
     end

data/lib/geocoder/lookups/mapbox.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/mapbox"
+
+module Geocoder::Lookup
+  class Mapbox < Base
+
+    def name
+      "Mapbox"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{url_query_string(query)}.json?access_token=#{configuration.api_key}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless data = fetch_data(query)
+      if data['features']
+        sort_relevant_feature(data['features'])
+      elsif data['message'] =~ /Invalid\sToken/
+        raise_error(Geocoder::InvalidApiKey, data['message'])
+      else
+        []
+      end
+    end
+
+    def url_query_string(query)
+      require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        "#{CGI.escape lon},#{CGI.escape lat}"
+      else
+        CGI.escape query.text.to_s
+      end
+    end
+
+    def dataset
+      configuration[:dataset] || "mapbox.places"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def sort_relevant_feature(features)
+      # Sort by descending relevance; Favor original order for equal relevance (eg occurs for reverse geocoding)
+      features.sort_by do |feature|
+        [feature["relevance"],-features.index(feature)]
+      end.reverse
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind_local.rb

@@ -36,7 +36,7 @@ module Geocoder::Lookup
         addr = IPAddr.new(query.text).to_i
         q = "SELECT l.country, l.region, l.city, l.latitude, l.longitude
           FROM maxmind_geolite_city_location l WHERE l.loc_id = (SELECT b.loc_id FROM maxmind_geolite_city_blocks b
-          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num LIMIT 1)"
+          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num)"
         format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
       elsif configuration[:package] == :country
         addr = IPAddr.new(query.text).to_i

data/lib/geocoder/lookups/telize.rb

@@ -8,13 +8,16 @@ module Geocoder::Lookup
       "Telize"
     end
 
+    def required_api_key_parts
+      ["key"]
+    end
+
     def query_url(query)
-      "http://www.telize.com/geoip/#{query.sanitized_text}"
+      "#{protocol}://telize-v1.p.mashape.com/geoip/#{query.sanitized_text}?mashape-key=#{api_key}"
     end
 
-    # currently doesn't support HTTPS
     def supported_protocols
-      [:http]
+      [:https]
     end
 
     private # ---------------------------------------------------------------
@@ -36,5 +39,9 @@ module Geocoder::Lookup
     def reserved_result(ip)
       {"message" => "Input string is not a valid IP address", "code" => 401}
     end
+
+    def api_key
+      configuration.api_key
+    end
   end
 end

data/lib/geocoder/lookups/yandex.rb

@@ -15,6 +15,10 @@ module Geocoder::Lookup
     def query_url(query)
       "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
     end
+    
+    def supported_protocols
+      [:https]
+    end
 
     private # ---------------------------------------------------------------
 

data/lib/geocoder/request.rb

@@ -17,7 +17,7 @@ module Geocoder
     #   corresponding to the original client IP for any request sent
     #   through a non-whitelisted proxy.
     def safe_location
-      @location ||= Geocoder.search(ip, ip_address: true).first
+      @safe_location ||= Geocoder.search(ip, ip_address: true).first
     end
 
     # There's a whole zoo of nonstandard headers added by various

data/lib/geocoder/results/esri.rb

@@ -4,12 +4,16 @@ module Geocoder::Result
   class Esri < Base
 
     def address
-      address = reverse_geocode? ? 'Address' : 'Match_addr'
-      attributes[address]
+      address_key = reverse_geocode? ? 'Address' : 'Match_addr'
+      attributes[address_key]
     end
 
     def city
-      attributes['City']
+      if !reverse_geocode? && is_city?
+        place_name
+      else
+        attributes['City']
+      end
     end
 
     def state_code
@@ -19,8 +23,8 @@ module Geocoder::Result
     alias_method :state, :state_code
 
     def country
-      country = reverse_geocode? ? "CountryCode" : "Country"
-      attributes[country]
+      country_key = reverse_geocode? ? "CountryCode" : "Country"
+      attributes[country_key]
     end
 
     alias_method :country_code, :country
@@ -29,6 +33,15 @@ module Geocoder::Result
       attributes['Postal']
     end
 
+    def place_name
+      place_name_key = reverse_geocode? ? "Address" : "PlaceName"
+      attributes[place_name_key]
+    end
+
+    def place_type
+      reverse_geocode? ? "Address" : attributes['Type']
+    end
+
     def coordinates
       [geometry["y"], geometry["x"]]
     end
@@ -47,5 +60,8 @@ module Geocoder::Result
       @data['locations'].nil?
     end
 
+    def is_city?
+      ['City', 'State Capital', 'National Capital'].include?(place_type)
+    end
   end
-end
+end

data/lib/geocoder/results/geoip2.rb

@@ -13,35 +13,35 @@ module Geocoder
       end
 
       def latitude
-        data.fetch('location',{}).fetch('latitude',0.0)
+        data.fetch('location', {}).fetch('latitude', 0.0)
       end
 
       def longitude
-        data.fetch('location',{}).fetch('longitude',0.0)
+        data.fetch('location', {}).fetch('longitude', 0.0)
       end
 
       def city
-        data.fetch('city', {}).fetch('names', {}).fetch('en', '')
+        data.fetch('city', {}).fetch('names', {}).fetch(locale, '')
       end
 
       def state
-        data.fetch('subdivisions',[]).fetch(0,{}).fetch('names',{}).fetch('en','')
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {}).fetch(locale, '')
       end
 
       def state_code
-        data.fetch('subdivisions',[]).fetch(0,{}).fetch('iso_code','')
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
       end
 
       def country
-        data.fetch('country', {}).fetch('names',{}).fetch('en','')
+        data.fetch('country', {}).fetch('names', {}).fetch(locale, '')
       end
 
       def country_code
-        data.fetch('country',{}).fetch('iso_code','')
+        data.fetch('country', {}).fetch('iso_code', '')
       end
 
       def postal_code
-        data.fetch('postal',{}).fetch('code','')
+        data.fetch('postal', {}).fetch('code', '')
       end
 
       def self.response_attributes
@@ -59,6 +59,10 @@ module Geocoder
       def data
         @data.to_hash
       end
+
+      def locale
+        @locale ||= Geocoder.config[:language].to_s
+      end
     end
   end
 end

data/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,69 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeoportailLu < Base
+
+    def coordinates
+      geomlonlat['coordinates'].reverse if geolocalized?
+    end
+
+    def address
+      full_address
+    end
+
+    def city
+      try_to_extract 'locality', detailled_address
+    end
+
+    def state
+      'Luxembourg'
+    end
+
+    def state_code
+      'LU'
+    end
+
+    def postal_code
+      try_to_extract 'zip', detailled_address
+    end
+
+    def street_address
+      [street_number, street].compact.join(' ')
+    end
+
+    def street_number
+      try_to_extract 'postnumber', detailled_address
+    end
+
+    def street
+      try_to_extract 'street', detailled_address
+    end
+
+    def full_address
+      data['address']
+    end
+
+    def geomlonlat
+      data['geomlonlat']
+    end
+
+    def detailled_address
+      data['AddressDetails']
+    end
+
+    alias_method :country, :state
+    alias_method :province, :state
+    alias_method :country_code, :state_code
+    alias_method :province_code, :state_code
+
+    private
+
+    def geolocalized?
+      try_to_extract('coordinates', geomlonlat).present?
+    end
+
+    def try_to_extract(key, nullable_hash)
+      nullable_hash.try(:[], key)
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -120,5 +120,13 @@ module Geocoder::Result
     def precision
       geometry['location_type'] if geometry
     end
+    
+    def partial_match
+      @data['partial_match']
+    end
+    
+    def place_id
+      @data['place_id']
+    end  
   end
 end

data/lib/geocoder/results/mapbox.rb

@@ -0,0 +1,55 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapbox < Base
+
+    def latitude
+      @latitude ||= @data["geometry"]["coordinates"].last.to_f
+    end
+
+    def longitude
+      @longitude ||= @data["geometry"]["coordinates"].first.to_f
+    end
+
+    def coordinates
+      [latitude, longitude]
+    end
+
+    def place_name
+      @data['text']
+    end
+
+    def street
+      @data['properties']['address']
+    end
+
+    def city
+      @data['context'].map { |c| c['text'] if c['id'] =~ /place/ }.compact.first
+    end
+
+    def state
+      @data['context'].map { |c| c['text'] if c['id'] =~ /region/ }.compact.first
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['context'].map { |c| c['text'] if c['id'] =~ /postcode/ }.compact.first
+    end
+
+    def country
+      @data['context'].map { |c| c['text'] if c['id'] =~ /country/ }.compact.first
+    end
+
+    alias_method :country_code, :country
+
+    def neighborhood
+      @data['context'].map { |c| c['text'] if c['id'] =~ /neighborhood/ }.compact.first
+    end
+
+    def address
+      [place_name, street, city, state, postal_code, country].compact.join(", ")
+    end
+  end
+end
+

data/lib/geocoder/results/mapquest.rb

@@ -26,6 +26,10 @@ module Geocoder::Result
       @data['adminArea3']
     end
 
+    def county
+      @data['adminArea4']
+    end
+
     alias_method :state_code, :state
 
     #FIXME: these might not be right, unclear with MQ documentation

data/lib/geocoder/results/pointpin.rb

@@ -23,10 +23,6 @@ module Geocoder::Result
       @data['country_name']
     end
 
-    def country_code
-      @data['country_code']
-    end
-
     def postal_code
       @data['postcode']
     end

data/lib/geocoder/stores/active_record.rb

@@ -28,6 +28,11 @@ module Geocoder::Store
             "OR #{table_name}.#{geocoder_options[:longitude]} IS NULL")
         }
 
+        # scope: not-reverse geocoded objects
+        scope :not_reverse_geocoded, lambda {
+          where("#{table_name}.#{geocoder_options[:fetched_address]} IS NULL")
+        }
+
         ##
         # Find all objects within a radius of the given location.
         # Location may be either a string to geocode or an array of
@@ -251,6 +256,17 @@ module Geocoder::Store
       end
     end
 
+    ##
+    # Get nearby geocoded objects.
+    # Takes the same options hash as the near class method (scope).
+    # Returns nil if the object is not geocoded.
+    #
+    def nearbys(radius = 20, options = {})
+      return nil unless geocoded?
+      options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
+      self.class.near(self, radius, options)
+    end
+
     ##
     # Look up coordinates and assign to +latitude+ and +longitude+ attributes
     # (or other as specified in +geocoded_by+). Returns coordinates (array).

data/lib/geocoder/stores/base.rb

@@ -55,17 +55,6 @@ module Geocoder
           point, to_coordinates, options)
       end
 
-      ##
-      # Get nearby geocoded objects.
-      # Takes the same options hash as the near class method (scope).
-      # Returns nil if the object is not geocoded.
-      #
-      def nearbys(radius = 20, options = {})
-        return nil unless geocoded?
-        options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
-        self.class.near(self, radius, options)
-      end
-
       ##
       # Look up coordinates and assign to +latitude+ and +longitude+ attributes
       # (or other as specified in +geocoded_by+). Returns coordinates (array).

data/lib/geocoder/stores/mongo_base.rb

@@ -11,37 +11,6 @@ module Geocoder::Store
         scope :not_geocoded, lambda {
           where(geocoder_options[:coordinates] => nil)
         }
-
-        scope :near, lambda{ |location, *args|
-          coords  = Geocoder::Calculations.extract_coordinates(location)
-
-          # no results if no lat/lon given
-          return where(:id => false) unless coords.is_a?(Array)
-
-          radius  = args.size > 0 ? args.shift : 20
-          options = args.size > 0 ? args.shift : {}
-          options[:units] ||= geocoder_options[:units]
-
-          # Use BSON::OrderedHash if Ruby's hashes are unordered.
-          # Conditions must be in order required by indexes (see mongo gem).
-          version = RUBY_VERSION.split('.').map { |i| i.to_i }
-          empty = version[0] < 2 && version[1] < 9 ? BSON::OrderedHash.new : {}
-
-          conds = empty.clone
-          field = geocoder_options[:coordinates]
-          conds[field] = empty.clone
-          conds[field]["$nearSphere"]  = coords.reverse
-
-          if radius
-            conds[field]["$maxDistance"] = \
-              Geocoder::Calculations.distance_to_radians(radius, options[:units])
-          end
-
-          if obj = options[:exclude]
-            conds[:_id.ne] = obj.id
-          end
-          where(conds)
-        }
       end
     end
 

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.2.9"
+  VERSION = "1.3.0"
 end

data/lib/geocoder.rb

@@ -1,5 +1,6 @@
 require "geocoder/configuration"
 require "geocoder/logger"
+require "geocoder/kernel_logger"
 require "geocoder/query"
 require "geocoder/calculations"
 require "geocoder/exceptions"

data/lib/maxmind_database.rb

@@ -21,7 +21,7 @@ module Geocoder
     end
 
     def insert(package, dir = "tmp")
-      data_files(package).each do |filepath,table|
+      data_files(package, dir).each do |filepath,table|
         print "Resetting table #{table}..."
         ActiveRecord::Base.connection.execute("DELETE FROM #{table}")
         puts "done"

data/lib/tasks/geocoder.rake

@@ -4,13 +4,22 @@ namespace :geocode do
     class_name = ENV['CLASS'] || ENV['class']
     sleep_timer = ENV['SLEEP'] || ENV['sleep']
     batch = ENV['BATCH'] || ENV['batch']
+    reverse = ENV['REVERSE'] || ENV['reverse']
     raise "Please specify a CLASS (model)" unless class_name
     klass = class_from_string(class_name)
     batch = batch.to_i unless batch.nil?
+    reverse = false unless reverse.to_s.downcase == 'true'
 
-    klass.not_geocoded.find_each(batch_size: batch) do |obj|
-      obj.geocode; obj.save
-      sleep(sleep_timer.to_f) unless sleep_timer.nil?
+    if reverse
+      klass.not_reverse_geocoded.find_each(batch_size: batch) do |obj|
+        obj.reverse_geocode; obj.save
+        sleep(sleep_timer.to_f) unless sleep_timer.nil?
+      end
+    else
+      klass.not_geocoded.find_each(batch_size: batch) do |obj|
+        obj.geocode; obj.save
+        sleep(sleep_timer.to_f) unless sleep_timer.nil?
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geocoder
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.3.0
 platform: ruby
 authors:
 - Alex Reisner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies: []
 description: Provides object geocoding (by street or IP address), reverse geocoding
   (coordinates to street address), distance queries for ActiveRecord and Mongoid,
@@ -43,6 +43,7 @@ files:
 - lib/geocoder/configuration_hash.rb
 - lib/geocoder/exceptions.rb
 - lib/geocoder/ip_address.rb
+- lib/geocoder/kernel_logger.rb
 - lib/geocoder/logger.rb
 - lib/geocoder/lookup.rb
 - lib/geocoder/lookups/baidu.rb
@@ -56,10 +57,12 @@ files:
 - lib/geocoder/lookups/geocoder_us.rb
 - lib/geocoder/lookups/geocodio.rb
 - lib/geocoder/lookups/geoip2.rb
+- lib/geocoder/lookups/geoportail_lu.rb
 - lib/geocoder/lookups/google.rb
 - lib/geocoder/lookups/google_places_details.rb
 - lib/geocoder/lookups/google_premier.rb
 - lib/geocoder/lookups/here.rb
+- lib/geocoder/lookups/mapbox.rb
 - lib/geocoder/lookups/mapquest.rb
 - lib/geocoder/lookups/maxmind.rb
 - lib/geocoder/lookups/maxmind_geoip2.rb
@@ -94,10 +97,12 @@ files:
 - lib/geocoder/results/geocoder_us.rb
 - lib/geocoder/results/geocodio.rb
 - lib/geocoder/results/geoip2.rb
+- lib/geocoder/results/geoportail_lu.rb
 - lib/geocoder/results/google.rb
 - lib/geocoder/results/google_places_details.rb
 - lib/geocoder/results/google_premier.rb
 - lib/geocoder/results/here.rb
+- lib/geocoder/results/mapbox.rb
 - lib/geocoder/results/mapquest.rb
 - lib/geocoder/results/maxmind.rb
 - lib/geocoder/results/maxmind_geoip2.rb
@@ -145,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Complete geocoding solution for Ruby.