geocoder 1.2.6 → 1.6.1

data/lib/geocoder/results/osmnames.rb

@@ -0,0 +1,56 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Osmnames < Base
+    def address
+      @data['display_name']
+    end
+
+    def coordinates
+      [@data['lat'].to_f, @data['lon'].to_f]
+    end
+
+    def viewport
+      west, south, east, north = @data['boundingbox'].map(&:to_f)
+      [south, west, north, east]
+    end
+
+    def state
+      @data['state']
+    end
+    alias_method :state_code, :state
+
+    def place_class
+      @data['class']
+    end
+
+    def place_type
+      @data['type']
+    end
+
+    def postal_code
+      ''
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def self.response_attributes
+      %w[house_number street city name osm_id osm_type boundingbox place_rank
+      importance county rank name_suffix]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/results/pelias.rb

@@ -0,0 +1,58 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Pelias < Base
+    def address(format = :full)
+      properties['label']
+    end
+
+    def city
+      locality
+    end
+
+    def coordinates
+      geometry['coordinates'].reverse
+    end
+
+    def country_code
+      properties['country_a']
+    end
+
+    def postal_code
+      properties['postalcode'].to_s
+    end
+
+    def province
+      state
+    end
+
+    def state
+      properties['region']
+    end
+
+    def state_code
+      properties['region_a']
+    end
+
+    def self.response_attributes
+      %w[county confidence country gid id layer localadmin locality neighborhood]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        properties[a]
+      end
+    end
+
+    private
+
+    def geometry
+      @data.fetch('geometry', {})
+    end
+
+    def properties
+      @data.fetch('properties', {})
+    end
+  end
+end
+

data/lib/geocoder/results/pickpoint.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/nominatim'
+
+module Geocoder::Result
+  class Pickpoint < Nominatim
+  end
+end

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/results/postcodes_io.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class PostcodesIo < Base
+
+    def coordinates
+      [@data['latitude'].to_f, @data['longitude'].to_f]
+    end
+
+    def quality
+      @data['quality']
+    end
+
+    def postal_code
+      @data['postcode']
+    end
+    alias address postal_code
+
+    def city
+      @data['admin_ward']
+    end
+
+    def county
+      @data['admin_county']
+    end
+    alias state county
+
+    def state_code
+      @data['codes']['admin_county']
+    end
+
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    end
+  end
+end

data/lib/geocoder/results/smarty_streets.rb

@@ -3,57 +3,89 @@ require 'geocoder/lookups/base'
 module Geocoder::Result
   class SmartyStreets < Base
     def coordinates
-      %w(latitude longitude).map do |i|
+      result = %w(latitude longitude).map do |i|
         zipcode_endpoint? ? zipcodes.first[i] : metadata[i]
       end
+
+      if result.compact.empty?
+        nil
+      else
+        result
+      end
     end
 
     def address
-      [
-        delivery_line_1,
-        delivery_line_2,
-        last_line
-      ].select{ |i| i.to_s != "" }.join(" ")
+      parts =
+        if international_endpoint?
+          (1..12).map { |i| @data["address#{i}"] }
+        else
+          [
+            delivery_line_1,
+            delivery_line_2,
+            last_line
+          ]
+        end
+      parts.select{ |i| i.to_s != "" }.join(" ")
     end
 
     def state
-      zipcode_endpoint? ?
-        city_states.first['state'] :
+      if international_endpoint?
+        components['administrative_area']
+      elsif zipcode_endpoint?
+        city_states.first['state']
+      else
         components['state_abbreviation']
+      end
     end
 
     def state_code
-      zipcode_endpoint? ?
-        city_states.first['state_abbreviation'] :
+      if international_endpoint?
+        components['administrative_area']
+      elsif zipcode_endpoint?
+        city_states.first['state_abbreviation']
+      else
         components['state_abbreviation']
+      end
     end
 
     def country
-      # SmartyStreets returns results for USA only
-      "United States"
+      international_endpoint? ?
+        components['country_iso_3'] :
+        "United States"
     end
 
     def country_code
-      # SmartyStreets returns results for USA only
-      "US"
+      international_endpoint? ?
+        components['country_iso_3'] :
+        "US"
     end
 
     ## Extra methods not in base.rb ------------------------
 
     def street
-      components['street_name']
+      international_endpoint? ?
+        components['thoroughfare_name'] :
+        components['street_name']
     end
 
     def city
-      zipcode_endpoint? ?
-        city_states.first['city'] :
+      if international_endpoint?
+        components['locality']
+      elsif zipcode_endpoint?
+        city_states.first['city']
+      else
         components['city_name']
+      end
     end
 
     def zipcode
-      zipcode_endpoint? ?
-        zipcodes.first['zipcode'] :
+      if international_endpoint?
+        components['postal_code']
+      elsif zipcode_endpoint?
+        zipcodes.first['zipcode']
+      else
         components['zipcode']
+      end
     end
     alias_method :postal_code, :zipcode
 
@@ -72,6 +104,10 @@ module Geocoder::Result
       zipcodes.any?
     end
 
+    def international_endpoint?
+      !@data['address1'].nil?
+    end
+
     [
       :delivery_line_1,
       :delivery_line_2,

data/lib/geocoder/results/telize.rb

@@ -3,11 +3,6 @@ require 'geocoder/results/base'
 module Geocoder::Result
   class Telize < Base
 
-    def address(format = :full)
-      s = state_code.to_s == "" ? "" : ", #{state_code}"
-      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
-    end
-
     def city
       @data['city']
     end

data/lib/geocoder/results/tencent.rb

@@ -0,0 +1,72 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Tencent < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    end
+
+    def address
+      "#{province}#{city}#{district}#{street}#{street_number}"
+
+      #@data['title'] or @data['address']
+    end
+
+    # NOTE: The Tencent reverse geocoding API has the field named
+    # 'address_component' compared to 'address_components' in the 
+    # regular geocoding API.
+    def province
+      @data['address_components'] and (@data['address_components']['province']) or 
+      (@data['address_component'] and @data['address_component']['province']) or
+      ""
+    end
+
+    alias_method :state, :province
+
+    def city
+      @data['address_components'] and (@data['address_components']['city']) or 
+      (@data['address_component'] and @data['address_component']['city']) or
+      ""
+    end
+
+    def district
+      @data['address_components'] and (@data['address_components']['district']) or 
+      (@data['address_component'] and @data['address_component']['district']) or
+      ""
+    end
+
+    def street
+      @data['address_components'] and (@data['address_components']['street']) or 
+      (@data['address_component'] and @data['address_component']['street']) or
+      ""
+    end
+
+    def street_number
+      @data['address_components'] and (@data['address_components']['street_number']) or 
+      (@data['address_component'] and @data['address_component']['street_number']) or
+      ""
+    end
+
+    def address_components
+      @data['address_components'] or @data['address_component']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+  end
+end

data/lib/geocoder/results/test.rb

@@ -15,7 +15,7 @@ module Geocoder
         end
       end
 
-      %w[latitude longitude neighborhood city state state_code sub_state
+      %w[coordinates neighborhood city state state_code sub_state
       sub_state_code province province_code postal_code country
       country_code address street_address street_number route geometry].each do |attr|
         add_result_attribute(attr)

data/lib/geocoder/results/yandex.rb

@@ -12,9 +12,10 @@ module Geocoder::Result
     end
 
     def city
-      if state.empty? and address_details.has_key? 'Locality'
+      if state.empty? and address_details and address_details.has_key? 'Locality'
         address_details['Locality']['LocalityName']
-      elsif sub_state.empty? and address_details['AdministrativeArea'].has_key? 'Locality'
+      elsif sub_state.empty? and address_details and address_details.has_key? 'AdministrativeArea' and
+          address_details['AdministrativeArea'].has_key? 'Locality'
         address_details['AdministrativeArea']['Locality']['LocalityName']
       elsif not sub_state_city.empty?
         sub_state_city
@@ -24,15 +25,23 @@ module Geocoder::Result
     end
 
     def country
-      address_details['CountryName']
+      if address_details
+        address_details['CountryName']
+      else
+        ""
+      end
     end
 
     def country_code
-      address_details['CountryNameCode']
+      if address_details
+        address_details['CountryNameCode']
+      else
+        ""
+      end
     end
 
     def state
-      if address_details['AdministrativeArea']
+      if address_details and address_details['AdministrativeArea']
         address_details['AdministrativeArea']['AdministrativeAreaName']
       else
         ""
@@ -40,7 +49,7 @@ module Geocoder::Result
     end
 
     def sub_state
-      if !state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea']
+      if !state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea']
         address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
       else
         ""
@@ -59,6 +68,14 @@ module Geocoder::Result
       address_details['Locality']['Premise']['PremiseName']
     end
 
+    def street
+      thoroughfare_data && thoroughfare_data['ThoroughfareName']
+    end
+
+    def street_number
+      thoroughfare_data && thoroughfare_data['Premise'] && thoroughfare_data['Premise']['PremiseNumber']
+    end
+
     def kind
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['kind']
     end
@@ -67,14 +84,47 @@ module Geocoder::Result
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
     end
 
+    def viewport
+      envelope = @data['GeoObject']['boundedBy']['Envelope'] || fail
+      east, north = envelope['upperCorner'].split(' ').map(&:to_f)
+      west, south = envelope['lowerCorner'].split(' ').map(&:to_f)
+      [south, west, north, east]
+    end
+
     private # ----------------------------------------------------------------
 
+    def thoroughfare_data
+      locality_data && locality_data['Thoroughfare']
+    end
+
+    def locality_data
+      dependent_locality && subadmin_locality && admin_locality
+    end
+
+    def admin_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['Locality']
+    end
+
+    def subadmin_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']
+    end
+
+    def dependent_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['DependentLocality']
+    end
+
     def address_details
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
     end
 
     def sub_state_city
-      if !sub_state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
+      if !sub_state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
         address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
       else
         ""

data/lib/geocoder/sql.rb

@@ -4,8 +4,8 @@ module Geocoder
 
     ##
     # Distance calculation for use with a database that supports POWER(),
-    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
-    # ATAN2(), DEGREES(), and RADIANS().
+    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(), 
+    # ATAN2().
     #
     # Based on the excellent tutorial at:
     # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
@@ -44,13 +44,13 @@ module Geocoder
     end
 
     def within_bounding_box(sw_lat, sw_lng, ne_lat, ne_lng, lat_attr, lon_attr)
-      spans = "#{lat_attr} BETWEEN #{sw_lat} AND #{ne_lat} AND "
+      spans = "#{lat_attr} BETWEEN #{sw_lat.to_f} AND #{ne_lat.to_f} AND "
       # handle box that spans 180 longitude
       if sw_lng.to_f > ne_lng.to_f
-        spans + "#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
-        "#{lon_attr} BETWEEN -180 AND #{ne_lng}"
+        spans + "(#{lon_attr} BETWEEN #{sw_lng.to_f} AND 180 OR " +
+        "#{lon_attr} BETWEEN -180 AND #{ne_lng.to_f})"
       else
-        spans + "#{lon_attr} BETWEEN #{sw_lng} AND #{ne_lng}"
+        spans + "#{lon_attr} BETWEEN #{sw_lng.to_f} AND #{ne_lng.to_f}"
       end
     end
 
@@ -59,6 +59,9 @@ module Geocoder
     # and an options hash which must include a :bearing value
     # (:linear or :spherical).
     #
+    # For use with a database that supports MOD() and trigonometric functions
+    # SIN(), COS(), ASIN(), ATAN2().
+    #
     # Based on:
     # http://www.beginningspatial.com/calculating_bearing_one_point_another
     #

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
@@ -55,7 +60,7 @@ module Geocoder::Store
         # corner followed by the northeast corner of the box
         # (<tt>[[sw_lat, sw_lon], [ne_lat, ne_lon]]</tt>).
         #
-        scope :within_bounding_box, lambda{ |bounds|
+        scope :within_bounding_box, lambda{ |*bounds|
           sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
           if sw_lat && sw_lng && ne_lat && ne_lng
             where(Geocoder::Sql.within_bounding_box(
@@ -82,8 +87,6 @@ module Geocoder::Store
         end
       end
 
-      private # ----------------------------------------------------------------
-
       ##
       # Get options hash suitable for passing to ActiveRecord.find to get
       # records within a radius (in kilometers) of the given point.
@@ -126,18 +129,31 @@ module Geocoder::Store
         distance_column = options.fetch(:distance_column) { 'distance' }
         bearing_column = options.fetch(:bearing_column)  { 'bearing' }
 
-        b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
+        # If radius is a DB column name, bounding box should include
+        # all rows within the maximum radius appearing in that column.
+        # Note: performance is dependent on variability of radii.
+        bb_radius = radius.is_a?(Symbol) ? maximum(radius) : radius
+        b = Geocoder::Calculations.bounding_box([latitude, longitude], bb_radius, options)
         args = b + [
           full_column_name(latitude_attribute),
           full_column_name(longitude_attribute)
         ]
         bounding_box_conditions = Geocoder::Sql.within_bounding_box(*args)
 
-        if using_sqlite?
+        if using_unextended_sqlite?
           conditions = bounding_box_conditions
         else
           min_radius = options.fetch(:min_radius, 0).to_f
-          conditions = [bounding_box_conditions + " AND (#{distance}) BETWEEN ? AND ?", min_radius, radius]
+          # if radius is a DB column name,
+          # find rows between min_radius and value in column
+          if radius.is_a?(Symbol)
+            c = "BETWEEN ? AND #{radius}"
+            a = [min_radius]
+          else
+            c = "BETWEEN ? AND ?"
+            a = [min_radius, radius]
+          end
+          conditions = [bounding_box_conditions + " AND (#{distance}) " + c] + a
         end
         {
           :select => select_clause(options[:select],
@@ -155,7 +171,7 @@ module Geocoder::Store
       # capabilities (trig functions?).
       #
       def distance_sql(latitude, longitude, options = {})
-        method_prefix = using_sqlite? ? "approx" : "full"
+        method_prefix = using_unextended_sqlite? ? "approx" : "full"
         Geocoder::Sql.send(
           method_prefix + "_distance",
           latitude, longitude,
@@ -174,7 +190,7 @@ module Geocoder::Store
           options[:bearing] = Geocoder.config.distances
         end
         if options[:bearing]
-          method_prefix = using_sqlite? ? "approx" : "full"
+          method_prefix = using_unextended_sqlite? ? "approx" : "full"
           Geocoder::Sql.send(
             method_prefix + "_bearing",
             latitude, longitude,
@@ -220,8 +236,20 @@ module Geocoder::Store
         conditions
       end
 
+      def using_unextended_sqlite?
+        using_sqlite? && !using_sqlite_with_extensions?
+      end
+
       def using_sqlite?
-        connection.adapter_name.match(/sqlite/i)
+        !!connection.adapter_name.match(/sqlite/i)
+      end
+
+      def using_sqlite_with_extensions?
+        connection.adapter_name.match(/sqlite/i) &&
+          defined?(::SqliteExt) &&
+          %W(MOD POWER SQRT PI SIN COS ASIN ATAN2).all?{ |fn_name|
+            connection.raw_connection.function_created?(fn_name)
+          }
       end
 
       def using_postgres?
@@ -239,7 +267,7 @@ module Geocoder::Store
       # Value which can be passed to where() to produce no results.
       #
       def false_condition
-        using_sqlite? ? 0 : "false"
+        using_unextended_sqlite? ? 0 : "false"
       end
 
       ##
@@ -251,6 +279,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).